epoch-tui 0.1.8 → 0.1.10

package/dist/index.js

@@ -4,7 +4,7 @@
 import { render } from "ink";
 
 // src/App.tsx
-import { Box as Box18, Text as Text15 } from "ink";
+import { Box as Box21, Text as Text18 } from "ink";
 
 // src/contexts/ThemeContext.tsx
 import { createContext as createContext2, useContext as useContext2, useState as useState2, useEffect as useEffect2 } from "react";
@@ -1453,7 +1453,8 @@ var getDefaultSchema = () => ({
     theme: "dark",
     defaultStartTime: "now",
     dateFormat: "MMMM do, yyyy",
-    timeFormat: "12h"
+    timeFormat: "12h",
+    autoMoveUnfinishedTasks: true
   }
 });
 var StorageService = class {
@@ -1527,6 +1528,10 @@ var StorageService = class {
       updatedAt: new Date(task.updatedAt),
       startTime: task.startTime ? new Date(task.startTime) : void 0,
       endTime: task.endTime ? new Date(task.endTime) : void 0,
+      recurrence: task.recurrence ? {
+        ...task.recurrence,
+        endDate: task.recurrence.endDate ? new Date(task.recurrence.endDate) : void 0
+      } : void 0,
       children: task.children ? task.children.map((child) => this.hydrateTask(child)) : []
     };
   }
@@ -1553,6 +1558,10 @@ var StorageService = class {
       updatedAt: task.updatedAt.toISOString(),
       startTime: task.startTime ? task.startTime.toISOString() : void 0,
       endTime: task.endTime ? task.endTime.toISOString() : void 0,
+      recurrence: task.recurrence ? {
+        ...task.recurrence,
+        endDate: task.recurrence.endDate ? task.recurrence.endDate.toISOString() : void 0
+      } : void 0,
       children: task.children ? task.children.map((child) => this.serializeTask(child)) : []
     };
   }
@@ -1769,8 +1778,185 @@ var useUndo = () => {
   return context;
 };
 
+// src/utils/date.ts
+import { format, startOfMonth, endOfMonth, eachDayOfInterval, startOfWeek, endOfWeek } from "date-fns";
+var formatDate = (date, formatStr = "MMM d, yyyy") => {
+  return format(date, formatStr);
+};
+var getDateString = (date) => {
+  return format(date, "yyyy-MM-dd");
+};
+var parseDateString = (dateStr) => {
+  const [year, month, day] = dateStr.split("-").map(Number);
+  return new Date(year, month - 1, day);
+};
+var generateMonthCalendar = (year, month) => {
+  const monthStart = startOfMonth(new Date(year, month, 1));
+  const monthEnd = endOfMonth(monthStart);
+  const calendarStart = startOfWeek(monthStart, { weekStartsOn: 1 });
+  const calendarEnd = endOfWeek(monthEnd, { weekStartsOn: 1 });
+  const days = eachDayOfInterval({ start: calendarStart, end: calendarEnd });
+  const weeks = [];
+  for (let i = 0; i < days.length; i += 7) {
+    weeks.push(days.slice(i, i + 7));
+  }
+  return weeks;
+};
+var isToday = (date) => {
+  const today = /* @__PURE__ */ new Date();
+  return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
+};
+
+// src/utils/logger.ts
+import fs2 from "fs";
+import path from "path";
+var Logger = class {
+  constructor() {
+    this.stream = null;
+    this.logFile = path.join(process.cwd(), "debug.log");
+    this.initializeLog();
+  }
+  initializeLog() {
+    if (fs2.existsSync(this.logFile)) {
+      fs2.unlinkSync(this.logFile);
+    }
+    this.stream = fs2.createWriteStream(this.logFile, { flags: "a" });
+    this.log("Logger initialized");
+  }
+  log(message, data) {
+    if (!this.stream) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const logMessage = data ? `[${timestamp}] ${message} ${JSON.stringify(data, null, 2)}
+` : `[${timestamp}] ${message}
+`;
+    this.stream.write(logMessage);
+  }
+  cleanup() {
+    this.log("Cleaning up logger");
+    if (this.stream) {
+      this.stream.end();
+      this.stream = null;
+    }
+    if (fs2.existsSync(this.logFile)) {
+      fs2.unlinkSync(this.logFile);
+    }
+  }
+};
+var logger = new Logger();
+process.on("exit", () => {
+  logger.cleanup();
+});
+process.on("SIGINT", () => {
+  logger.cleanup();
+  process.exit(0);
+});
+process.on("SIGTERM", () => {
+  logger.cleanup();
+  process.exit(0);
+});
+
+// src/services/taskMoveService.ts
+var TaskMoveService = class {
+  /**
+   * Get all unfinished tasks from a specific date
+   */
+  getUnfinishedTasks(tasks) {
+    const unfinished = [];
+    const traverse = (taskList) => {
+      for (const task of taskList) {
+        if (task.state === "todo") {
+          unfinished.push(task);
+        }
+        if (task.children.length > 0) {
+          traverse(task.children);
+        }
+      }
+    };
+    traverse(tasks);
+    return unfinished;
+  }
+  /**
+   * Move unfinished tasks from a previous date to a new date
+   */
+  moveUnfinishedTasksToDate(tasks, fromDate, toDate) {
+    const sourceTasks = tasks[fromDate] || [];
+    const unfinishedTasks = this.getUnfinishedTasks(sourceTasks);
+    if (unfinishedTasks.length === 0) {
+      logger.log(`No unfinished tasks to move from ${fromDate} to ${toDate}`);
+      return tasks;
+    }
+    logger.log(`Moving ${unfinishedTasks.length} tasks from ${fromDate} to ${toDate}`, {
+      taskIds: unfinishedTasks.map((t) => t.id),
+      taskTitles: unfinishedTasks.map((t) => t.title)
+    });
+    const movedTasks = unfinishedTasks.map((task) => ({
+      ...task,
+      date: toDate,
+      startTime: void 0,
+      endTime: void 0,
+      updatedAt: /* @__PURE__ */ new Date()
+    }));
+    const targetTasks = tasks[toDate] || [];
+    const newTargetTasks = [...targetTasks, ...movedTasks];
+    const newSourceTasks = sourceTasks.filter(
+      (task) => !unfinishedTasks.some((ut) => ut.id === task.id)
+    );
+    return {
+      ...tasks,
+      [fromDate]: newSourceTasks,
+      [toDate]: newTargetTasks
+    };
+  }
+  /**
+   * Get all dates that have unfinished tasks before a given date
+   */
+  getDatesWithUnfinishedTasks(tasks, beforeDate) {
+    const dates = [];
+    const beforeDateStr = getDateString(beforeDate);
+    for (const [dateStr, taskList] of Object.entries(tasks)) {
+      if (dateStr < beforeDateStr) {
+        const unfinished = this.getUnfinishedTasks(taskList);
+        if (unfinished.length > 0) {
+          dates.push(dateStr);
+        }
+      }
+    }
+    return dates.sort();
+  }
+  /**
+   * Auto-move all unfinished tasks from previous days to today
+   */
+  /**
+   * Auto-move all unfinished tasks from previous days to today
+   */
+  autoMoveUnfinishedTasksToToday(tasks) {
+    const today = /* @__PURE__ */ new Date();
+    const todayStr = getDateString(today);
+    const datesWithUnfinished = this.getDatesWithUnfinishedTasks(tasks, today);
+    logger.log("Starting auto-move of unfinished tasks", {
+      today: todayStr,
+      datesWithUnfinished
+    });
+    let updatedTasks = { ...tasks };
+    for (const dateStr of datesWithUnfinished) {
+      updatedTasks = this.moveUnfinishedTasksToDate(
+        updatedTasks,
+        dateStr,
+        todayStr
+      );
+      logger.log(`Moved tasks from ${dateStr} to ${todayStr}`);
+    }
+    logger.log("Auto-move completed", {
+      tasksMoved: datesWithUnfinished.length,
+      fromDates: datesWithUnfinished
+    });
+    return updatedTasks;
+  }
+};
+var taskMoveService = new TaskMoveService();
+
 // src/utils/version.ts
-var CURRENT_VERSION = "0.1.8";
+var CURRENT_VERSION = "0.1.9";
 var PACKAGE_NAME = "epoch-tui";
 async function checkForUpdate() {
   try {
@@ -1826,6 +2012,11 @@ var AppProvider = ({ children }) => {
   const [exitConfirmation, setExitConfirmation] = useState4(false);
   const [showThemeDialog, setShowThemeDialog] = useState4(false);
   const [showClearTimelineDialog, setShowClearTimelineDialog] = useState4(false);
+  const [showSettingsDialog, setShowSettingsDialog] = useState4(false);
+  const [showRecurringTaskDialog, setShowRecurringTaskDialog] = useState4(false);
+  const [recurringTaskId, setRecurringTaskId] = useState4(null);
+  const [showRecurringEditDialog, setShowRecurringEditDialog] = useState4(false);
+  const [recurringEditConfig, setRecurringEditConfig] = useState4(null);
   const [showUpdateDialog, setShowUpdateDialog] = useState4(false);
   const [updateInfo, setUpdateInfo] = useState4(null);
   const clearTimelineForDate = useCallback3((dateStr) => {
@@ -1873,7 +2064,25 @@ var AppProvider = ({ children }) => {
   }, [data, save]);
   useEffect3(() => {
     if (data && !initialLoadDone.current) {
-      setTasks(data.tasks);
+      logger.log("Loading data from storage", {
+        settings: data.settings,
+        taskDates: Object.keys(data.tasks),
+        timelineDates: Object.keys(data.timeline)
+      });
+      let tasksToSet = data.tasks;
+      if (data.settings?.autoMoveUnfinishedTasks !== false) {
+        logger.log("Auto-move enabled, moving unfinished tasks");
+        tasksToSet = taskMoveService.autoMoveUnfinishedTasksToToday(data.tasks);
+        if (tasksToSet !== data.tasks) {
+          saveRef.current({
+            ...data,
+            tasks: tasksToSet
+          });
+        }
+      } else {
+        logger.log("Auto-move disabled, skipping");
+      }
+      setTasks(tasksToSet);
       setTimeline(data.timeline);
       initialLoadDone.current = true;
       checkForUpdate().then((info) => {
@@ -1894,6 +2103,10 @@ var AppProvider = ({ children }) => {
         tasks,
         timeline
       });
+      logger.log("Auto-saving data", {
+        taskCount: Object.keys(tasks).reduce((acc, date) => acc + tasks[date].length, 0),
+        timelineCount: Object.keys(timeline).reduce((acc, date) => acc + (timeline[date]?.length || 0), 0)
+      });
     }
   }, [tasks, timeline]);
   return /* @__PURE__ */ jsx4(
@@ -1922,8 +2135,18 @@ var AppProvider = ({ children }) => {
         setShowThemeDialog,
         showClearTimelineDialog,
         setShowClearTimelineDialog,
+        showSettingsDialog,
+        setShowSettingsDialog,
+        showRecurringTaskDialog,
+        setShowRecurringTaskDialog,
+        recurringTaskId,
+        setRecurringTaskId,
+        showRecurringEditDialog,
+        setShowRecurringEditDialog,
+        recurringEditConfig,
+        setRecurringEditConfig,
         clearTimelineForDate,
-        isModalOpen: showHelp || showThemeDialog || showOverview || showClearTimelineDialog || showUpdateDialog,
+        isModalOpen: showHelp || showThemeDialog || showOverview || showClearTimelineDialog || showUpdateDialog || showSettingsDialog || showRecurringTaskDialog || showRecurringEditDialog,
         saveNow,
         pushUndoableAction,
         performUndo,
@@ -1949,7 +2172,7 @@ var useApp = () => {
 import { useInput } from "ink";
 import { useEffect as useEffect4 } from "react";
 var useKeyboardNav = () => {
-  const { showHelp, setShowHelp, activePane, setActivePane, isInputMode, showOverview, setShowOverview, overviewMonth, setOverviewMonth, exitConfirmation, setExitConfirmation, showThemeDialog, setShowThemeDialog, showClearTimelineDialog, setShowClearTimelineDialog, saveNow, performUndo, canUndo } = useApp();
+  const { showHelp, setShowHelp, activePane, setActivePane, isInputMode, showOverview, setShowOverview, overviewMonth, setOverviewMonth, exitConfirmation, setExitConfirmation, showThemeDialog, setShowThemeDialog, showClearTimelineDialog, setShowClearTimelineDialog, showSettingsDialog, setShowSettingsDialog, showRecurringTaskDialog, showRecurringEditDialog, showUpdateDialog, saveNow, performUndo, canUndo } = useApp();
   useEffect4(() => {
     if (exitConfirmation) {
       const timer = setTimeout(() => {
@@ -1958,10 +2181,11 @@ var useKeyboardNav = () => {
       return () => clearTimeout(timer);
     }
   }, [exitConfirmation, setExitConfirmation]);
-  const isActive = !isInputMode && !showThemeDialog && !showClearTimelineDialog;
+  const isActive = !isInputMode && !showThemeDialog && !showClearTimelineDialog && !showSettingsDialog && !showRecurringTaskDialog && !showRecurringEditDialog && !showUpdateDialog;
   useInput((input, key) => {
     if (key.ctrl && input === "c") {
       if (exitConfirmation) {
+        logger.log("Exiting application");
         saveNow().then(() => {
           const inkApp = global.__inkApp;
           if (inkApp) {
@@ -1985,39 +2209,55 @@ var useKeyboardNav = () => {
         });
         return;
       } else {
+        logger.log("Exit confirmation requested");
         setExitConfirmation(true);
         return;
       }
     }
+  });
+  useInput((input, key) => {
     if (key.ctrl && input === "u" && canUndo) {
+      logger.log("Performing undo");
       performUndo();
       return;
     }
     if (input === ":") {
+      logger.log("Toggling overview", { show: !showOverview });
       setShowOverview(!showOverview);
       return;
     }
     if (input === "?") {
+      logger.log("Toggling help dialog", { show: !showHelp });
       setShowHelp(!showHelp);
       return;
     }
     if (key.ctrl && input === "t") {
+      logger.log("Opening theme dialog");
       setShowThemeDialog(true);
       return;
     }
+    if (key.ctrl && input === "s") {
+      logger.log("Opening settings dialog");
+      setShowSettingsDialog(true);
+      return;
+    }
     if (input === "C" && activePane === "timeline") {
+      logger.log("Opening clear timeline dialog");
       setShowClearTimelineDialog(true);
       return;
     }
     if (input === "1") {
+      logger.log("Switching to calendar pane");
       setActivePane("calendar");
       return;
     }
     if (input === "2" || key.tab && !key.shift) {
+      logger.log("Switching to tasks pane");
       setActivePane("tasks");
       return;
     }
     if (input === "3" || key.tab && key.shift) {
+      logger.log("Switching to timeline pane");
       setActivePane("timeline");
       return;
     }
@@ -2270,31 +2510,6 @@ var KeyboardHints = ({ hints }) => {
   );
 };
 
-// src/utils/date.ts
-import { format, startOfMonth, endOfMonth, eachDayOfInterval, startOfWeek, endOfWeek } from "date-fns";
-var formatDate = (date, formatStr = "MMM d, yyyy") => {
-  return format(date, formatStr);
-};
-var getDateString = (date) => {
-  return format(date, "yyyy-MM-dd");
-};
-var generateMonthCalendar = (year, month) => {
-  const monthStart = startOfMonth(new Date(year, month, 1));
-  const monthEnd = endOfMonth(monthStart);
-  const calendarStart = startOfWeek(monthStart);
-  const calendarEnd = endOfWeek(monthEnd);
-  const days = eachDayOfInterval({ start: calendarStart, end: calendarEnd });
-  const weeks = [];
-  for (let i = 0; i < days.length; i += 7) {
-    weeks.push(days.slice(i, i + 7));
-  }
-  return weeks;
-};
-var isToday = (date) => {
-  const today = /* @__PURE__ */ new Date();
-  return date.getDate() === today.getDate() && date.getMonth() === today.getMonth() && date.getFullYear() === today.getFullYear();
-};
-
 // src/services/calendarService.ts
 var CalendarService = class {
   generateMonthView(year, month, selectedDate, tasks) {
@@ -2490,9 +2705,9 @@ import { useState as useState7, useEffect as useEffect8, useMemo } from "react";
 import { Box as Box8, Text as Text7, useInput as useInput4 } from "ink";
 
 // src/components/common/ControlledTextInput.tsx
-import { useRef as useRef3, useEffect as useEffect7 } from "react";
+import { useRef as useRef3, useReducer, useEffect as useEffect7 } from "react";
 import { Text as Text5, useInput as useInput3 } from "ink";
-import { jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
+import { Fragment, jsx as jsx12, jsxs as jsxs7 } from "react/jsx-runtime";
 var ControlledTextInput = ({
   value,
   onChange,
@@ -2505,22 +2720,39 @@ var ControlledTextInput = ({
   color,
   maxLength
 }) => {
-  const pendingValueRef = useRef3(value);
+  const valueRef = useRef3(value);
+  const cursorRef = useRef3(value.length);
+  const [, forceRender] = useReducer((x) => x + 1, 0);
   const sentValuesRef = useRef3(/* @__PURE__ */ new Set([value]));
   useEffect7(() => {
-    if (value === pendingValueRef.current) {
+    if (value === valueRef.current) {
       return;
     }
     if (sentValuesRef.current.has(value)) {
       return;
     }
-    pendingValueRef.current = value;
+    valueRef.current = value;
+    cursorRef.current = value.length;
     sentValuesRef.current.clear();
     sentValuesRef.current.add(value);
+    forceRender();
   }, [value]);
+  const findWordStart = (text, pos) => {
+    let i = pos - 1;
+    while (i >= 0 && text[i] === " ") i--;
+    while (i >= 0 && text[i] !== " ") i--;
+    return i + 1;
+  };
+  const findWordEnd = (text, pos) => {
+    let i = pos;
+    while (i < text.length && text[i] === " ") i++;
+    while (i < text.length && text[i] !== " ") i++;
+    return i;
+  };
   useInput3(
     (input, key) => {
-      const currentValue = pendingValueRef.current;
+      const currentValue = valueRef.current;
+      const cursor2 = cursorRef.current;
       if (key.escape) {
         onCancel?.();
         return;
@@ -2531,32 +2763,92 @@ var ControlledTextInput = ({
       }
       if (input === "\r" || input === "\n") return;
       let nextValue = currentValue;
-      if (key.backspace || key.delete) {
-        nextValue = currentValue.slice(0, -1);
+      let nextCursor = cursor2;
+      if (key.backspace) {
+        if (key.ctrl) {
+          const wordStart = findWordStart(currentValue, cursor2);
+          nextValue = currentValue.slice(0, wordStart) + currentValue.slice(cursor2);
+          nextCursor = wordStart;
+        } else if (cursor2 > 0) {
+          nextValue = currentValue.slice(0, cursor2 - 1) + currentValue.slice(cursor2);
+          nextCursor = cursor2 - 1;
+        }
+      } else if (key.delete) {
+        if (cursor2 >= currentValue.length && cursor2 > 0) {
+          nextValue = currentValue.slice(0, cursor2 - 1) + currentValue.slice(cursor2);
+          nextCursor = cursor2 - 1;
+        } else if (cursor2 < currentValue.length) {
+          nextValue = currentValue.slice(0, cursor2) + currentValue.slice(cursor2 + 1);
+        }
+      } else if (key.leftArrow && !key.ctrl) {
+        nextCursor = Math.max(0, cursor2 - 1);
+      } else if (key.rightArrow && !key.ctrl) {
+        nextCursor = Math.min(currentValue.length, cursor2 + 1);
+      } else if (key.leftArrow && key.ctrl) {
+        const wordStart = findWordStart(currentValue, cursor2);
+        nextCursor = wordStart;
+      } else if (key.rightArrow && key.ctrl) {
+        const wordEnd = findWordEnd(currentValue, cursor2);
+        nextCursor = wordEnd;
+      } else if (key.meta && input === "b") {
+        const wordStart = findWordStart(currentValue, cursor2);
+        nextCursor = wordStart;
+      } else if (key.meta && input === "f") {
+        const wordEnd = findWordEnd(currentValue, cursor2);
+        nextCursor = wordEnd;
+      } else if (key.ctrl && input === "a") {
+        nextCursor = 0;
+      } else if (key.ctrl && input === "e") {
+        nextCursor = currentValue.length;
+      } else if (key.ctrl && input === "u") {
+        nextValue = currentValue.slice(cursor2);
+        nextCursor = 0;
+      } else if (key.ctrl && input === "k") {
+        nextValue = currentValue.slice(0, cursor2);
+      } else if (key.ctrl && input === "w") {
+        const wordStart = findWordStart(currentValue, cursor2);
+        nextValue = currentValue.slice(0, wordStart) + currentValue.slice(cursor2);
+        nextCursor = wordStart;
       } else if (!key.ctrl && !key.meta && input.length > 0) {
         const filtered = input.replace(/[\x00-\x1F\x7F]/g, "");
         if (filtered) {
-          const possibleValue = currentValue + filtered;
-          if (maxLength && possibleValue.length > maxLength) {
-            return;
+          const possibleValue = currentValue.slice(0, cursor2) + filtered + currentValue.slice(cursor2);
+          if (!maxLength || possibleValue.length <= maxLength) {
+            nextValue = possibleValue;
+            nextCursor = cursor2 + filtered.length;
           }
-          nextValue = possibleValue;
         }
+      } else {
+        return;
       }
-      if (nextValue !== currentValue) {
-        pendingValueRef.current = nextValue;
-        sentValuesRef.current.add(nextValue);
-        onChange(nextValue);
+      const valueChanged = nextValue !== currentValue;
+      const cursorChanged = nextCursor !== cursor2;
+      if (valueChanged || cursorChanged) {
+        valueRef.current = nextValue;
+        cursorRef.current = nextCursor;
+        if (valueChanged) {
+          sentValuesRef.current.add(nextValue);
+          onChange(nextValue);
+        }
+        forceRender();
       }
     },
     { isActive: focus }
   );
-  const displayValue = pendingValueRef.current || "";
+  const displayValue = valueRef.current;
+  const cursor = cursorRef.current;
   const showPlaceholder = !displayValue && placeholder;
-  return /* @__PURE__ */ jsxs7(Text5, { children: [
-    showPlaceholder ? /* @__PURE__ */ jsx12(Text5, { dimColor: true, color: placeholderColor, children: placeholder }) : /* @__PURE__ */ jsx12(Text5, { color, children: displayValue }),
+  const beforeCursor = displayValue.slice(0, cursor);
+  const atCursor = displayValue[cursor] || " ";
+  const afterCursor = displayValue.slice(cursor + 1);
+  return /* @__PURE__ */ jsx12(Text5, { children: showPlaceholder ? /* @__PURE__ */ jsxs7(Fragment, { children: [
+    /* @__PURE__ */ jsx12(Text5, { dimColor: true, color: placeholderColor, children: placeholder }),
     focus && /* @__PURE__ */ jsx12(Text5, { backgroundColor: cursorColor, children: " " })
-  ] });
+  ] }) : /* @__PURE__ */ jsxs7(Fragment, { children: [
+    /* @__PURE__ */ jsx12(Text5, { color, children: beforeCursor }),
+    focus ? /* @__PURE__ */ jsx12(Text5, { color, backgroundColor: cursorColor, children: atCursor }) : /* @__PURE__ */ jsx12(Text5, { color, children: atCursor }),
+    /* @__PURE__ */ jsx12(Text5, { color, children: afterCursor })
+  ] }) });
 };
 
 // src/components/tasks/TaskHeader.tsx
@@ -2589,8 +2881,20 @@ var findTaskById = (tasks, id) => {
   return null;
 };
 var updateTaskInTree = (tasks, id, updates) => {
-  return tasks.map((task) => {
+  logger.log("[updateTaskInTree] Called", {
+    id,
+    updates,
+    tasksCount: tasks.length,
+    tasksIds: tasks.map((t) => ({ id: t.id, title: t.title, childrenCount: t.children.length }))
+  });
+  const result = tasks.map((task) => {
     if (task.id === id) {
+      logger.log("[updateTaskInTree] Found task to update", {
+        id,
+        taskTitle: task.title,
+        currentState: task.state,
+        updates
+      });
       return { ...task, ...updates, updatedAt: /* @__PURE__ */ new Date() };
     }
     return {
@@ -2598,6 +2902,11 @@ var updateTaskInTree = (tasks, id, updates) => {
       children: updateTaskInTree(task.children, id, updates)
     };
   });
+  logger.log("[updateTaskInTree] Completed", {
+    id,
+    resultCount: result.length
+  });
+  return result;
 };
 var deleteTaskFromTree = (tasks, id) => {
   return tasks.filter((task) => task.id !== id).map((task) => ({
@@ -2684,6 +2993,7 @@ var TaskService = class {
     if (!validation.valid) {
       throw new Error(validation.error);
     }
+    logger.log("Creating new task", { title, date, state });
     const now = /* @__PURE__ */ new Date();
     return {
       id: uuid(),
@@ -2696,6 +3006,7 @@ var TaskService = class {
     };
   }
   updateTask(tasks, taskId, updates) {
+    logger.log("Updating task", { taskId, updates });
     const dateStr = Object.keys(tasks).find(
       (date) => findTaskById(tasks[date], taskId)
     );
@@ -2727,11 +3038,13 @@ var TaskService = class {
     };
   }
   deleteTask(tasks, taskId) {
+    logger.log("Deleting task", { taskId });
     const dateStr = Object.keys(tasks).find(
       (date) => findTaskById(tasks[date], taskId)
     );
     if (!dateStr) {
-      throw new Error("Task not found");
+      logger.log("Task not found for deletion, it might be an ephemeral recurring instance", { taskId });
+      return tasks;
     }
     return {
       ...tasks,
@@ -2759,6 +3072,7 @@ var TaskService = class {
     };
   }
   changeTaskState(tasks, taskId, newState) {
+    logger.log("Changing task state", { taskId, newState });
     return this.updateTask(tasks, taskId, {
       state: newState,
       endTime: ["completed", "delegated", "delayed"].includes(newState) ? /* @__PURE__ */ new Date() : void 0
@@ -2781,6 +3095,36 @@ var TaskService = class {
   getTaskStats(tasks, date) {
     return getTaskStats(this.getTasksForDate(tasks, date));
   }
+  excludeRecurringInstance(tasks, parentTaskId, dateStr) {
+    logger.log("Excluding recurring instance", { parentTaskId, dateStr });
+    const parentDateStr = Object.keys(tasks).find(
+      (date) => tasks[date].some((t) => t.id === parentTaskId)
+    );
+    if (!parentDateStr) {
+      throw new Error("Parent recurring task not found");
+    }
+    return {
+      ...tasks,
+      [parentDateStr]: tasks[parentDateStr].map((task) => {
+        if (task.id === parentTaskId) {
+          const recurrence = task.recurrence;
+          if (!recurrence) return task;
+          const excludedDates = recurrence.excludedDates || [];
+          if (!excludedDates.includes(dateStr)) {
+            return {
+              ...task,
+              recurrence: {
+                ...recurrence,
+                excludedDates: [...excludedDates, dateStr]
+              },
+              updatedAt: /* @__PURE__ */ new Date()
+            };
+          }
+        }
+        return task;
+      })
+    };
+  }
 };
 var taskService = new TaskService();
 
@@ -2855,8 +3199,208 @@ var TimelineService = class {
 };
 var timelineService = new TimelineService();
 
+// src/services/recurringTaskService.ts
+import { addDays as addDays2, addWeeks as addWeeks2, addMonths, addYears, isWeekend, isBefore, isAfter, isSameDay as isSameDay2 } from "date-fns";
+import { v4 as uuid3 } from "uuid";
+var RecurringTaskService = class {
+  /**
+   * Check if a date matches the recurrence pattern
+   */
+  shouldGenerateOnDate(pattern, baseDate, targetDate) {
+    const targetDateStr = getDateString(targetDate);
+    if (pattern.excludedDates && pattern.excludedDates.includes(targetDateStr)) {
+      return false;
+    }
+    if (isBefore(targetDate, baseDate)) {
+      return false;
+    }
+    if (pattern.endDate && isAfter(targetDate, pattern.endDate)) {
+      return false;
+    }
+    if (isSameDay2(baseDate, targetDate)) {
+      return false;
+    }
+    switch (pattern.frequency) {
+      case "daily":
+        return true;
+      case "weekdays":
+        return !isWeekend(targetDate);
+      case "weekly": {
+        const daysDiff = Math.floor(
+          (targetDate.getTime() - baseDate.getTime()) / (1e3 * 60 * 60 * 24)
+        );
+        return daysDiff % 7 === 0;
+      }
+      case "monthly": {
+        return targetDate.getDate() === baseDate.getDate();
+      }
+      case "yearly": {
+        return targetDate.getMonth() === baseDate.getMonth() && targetDate.getDate() === baseDate.getDate();
+      }
+      case "custom": {
+        if (pattern.daysOfWeek && pattern.daysOfWeek.length > 0) {
+          return pattern.daysOfWeek.includes(targetDate.getDay());
+        }
+        if (pattern.interval) {
+          const daysDiff = Math.floor(
+            (targetDate.getTime() - baseDate.getTime()) / (1e3 * 60 * 60 * 24)
+          );
+          return daysDiff % pattern.interval === 0;
+        }
+        return false;
+      }
+      default:
+        return false;
+    }
+  }
+  /**
+   * Clone children tasks recursively for recurring instances
+   */
+  cloneChildren(children, targetDateStr) {
+    return children.map((child) => ({
+      ...child,
+      id: uuid3(),
+      date: targetDateStr,
+      state: "todo",
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      startTime: void 0,
+      endTime: void 0,
+      // Recursively clone nested children
+      children: this.cloneChildren(child.children, targetDateStr)
+    }));
+  }
+  /**
+   * Generate recurring task instance for a specific date
+   */
+  generateRecurringInstance(parentTask, targetDate) {
+    const targetDateStr = getDateString(targetDate);
+    const parentDateStr = parentTask.date;
+    logger.log("Generating recurring instance", {
+      parentTaskId: parentTask.id,
+      parentTaskTitle: parentTask.title,
+      parentDate: parentDateStr,
+      targetDate: targetDateStr,
+      recurrence: parentTask.recurrence,
+      childrenCount: parentTask.children.length
+    });
+    return {
+      ...parentTask,
+      id: uuid3(),
+      date: targetDateStr,
+      state: "todo",
+      createdAt: /* @__PURE__ */ new Date(),
+      updatedAt: /* @__PURE__ */ new Date(),
+      startTime: void 0,
+      endTime: void 0,
+      isRecurringInstance: true,
+      recurringParentId: parentTask.id,
+      // Clone children for recurring instances
+      children: this.cloneChildren(parentTask.children, targetDateStr)
+    };
+  }
+  /**
+   * Get the next occurrence date for a recurring task
+   */
+  getNextOccurrence(pattern, baseDate) {
+    let nextDate = new Date(baseDate);
+    switch (pattern.frequency) {
+      case "daily":
+        nextDate = addDays2(baseDate, 1);
+        break;
+      case "weekdays": {
+        nextDate = addDays2(baseDate, 1);
+        while (isWeekend(nextDate)) {
+          nextDate = addDays2(nextDate, 1);
+        }
+        break;
+      }
+      case "weekly":
+        nextDate = addWeeks2(baseDate, 1);
+        break;
+      case "monthly":
+        nextDate = addMonths(baseDate, 1);
+        break;
+      case "yearly":
+        nextDate = addYears(baseDate, 1);
+        break;
+      case "custom": {
+        if (pattern.daysOfWeek && pattern.daysOfWeek.length > 0) {
+          nextDate = addDays2(baseDate, 1);
+          while (!pattern.daysOfWeek.includes(nextDate.getDay())) {
+            nextDate = addDays2(nextDate, 1);
+            if (nextDate.getTime() - baseDate.getTime() > 7 * 24 * 60 * 60 * 1e3) {
+              return null;
+            }
+          }
+        } else if (pattern.interval) {
+          nextDate = addDays2(baseDate, pattern.interval);
+        } else {
+          return null;
+        }
+        break;
+      }
+      default:
+        return null;
+    }
+    if (pattern.endDate && isAfter(nextDate, pattern.endDate)) {
+      return null;
+    }
+    return nextDate;
+  }
+  /**
+   * Generate frequency description for display
+   */
+  getFrequencyDescription(pattern) {
+    switch (pattern.frequency) {
+      case "daily":
+        return "Daily";
+      case "weekdays":
+        return "Weekdays (Mon-Fri)";
+      case "weekly":
+        return "Weekly";
+      case "monthly":
+        return "Monthly";
+      case "yearly":
+        return "Yearly";
+      case "custom": {
+        if (pattern.daysOfWeek && pattern.daysOfWeek.length > 0) {
+          const dayNames = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
+          const days = pattern.daysOfWeek.map((d) => dayNames[d]).join(", ");
+          return `Custom (${days})`;
+        }
+        if (pattern.interval) {
+          return `Every ${pattern.interval} days`;
+        }
+        return "Custom";
+      }
+      default:
+        return "Unknown";
+    }
+  }
+  /**
+   * Check if a task should generate an instance for a specific date
+   */
+  shouldTaskGenerateForDate(task, targetDate) {
+    if (!task.recurrence) {
+      return false;
+    }
+    const baseDate = parseDateString(task.date);
+    const shouldGenerate = this.shouldGenerateOnDate(task.recurrence, baseDate, targetDate);
+    logger.log("Checking if task should generate for date", {
+      taskId: task.id,
+      taskTitle: task.title,
+      targetDate: getDateString(targetDate),
+      recurrence: task.recurrence,
+      shouldGenerate
+    });
+    return shouldGenerate;
+  }
+};
+var recurringTaskService = new RecurringTaskService();
+
 // src/components/tasks/TasksPane.tsx
-import { Fragment, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx14, jsxs as jsxs9 } from "react/jsx-runtime";
 var TasksPane = () => {
   const {
     tasks,
@@ -2868,7 +3412,12 @@ var TasksPane = () => {
     isInputMode,
     setIsInputMode,
     isModalOpen,
-    pushUndoableAction
+    pushUndoableAction,
+    setShowRecurringTaskDialog,
+    setRecurringTaskId,
+    setShowRecurringEditDialog,
+    setRecurringEditConfig,
+    recurringEditConfig
   } = useApp();
   const { theme } = useTheme();
   const [expandedIds, setExpandedIds] = useState7(/* @__PURE__ */ new Set());
@@ -2877,14 +3426,72 @@ var TasksPane = () => {
   const [editValue, setEditValue] = useState7("");
   const [parentTaskId, setParentTaskId] = useState7(null);
   const [scrollOffset, setScrollOffset] = useState7(0);
+  const [editingTaskId, setEditingTaskId] = useState7(null);
+  const [pendingAction, setPendingAction] = useState7(null);
   const { height: terminalHeight } = useTerminalSize();
   const visibleRows = useMemo(() => {
     return Math.max(5, terminalHeight - 11);
   }, [terminalHeight]);
-  const selectedDateObj = new Date(selectedDate.year, selectedDate.month, selectedDate.day);
+  const selectedDateObj = useMemo(
+    () => new Date(selectedDate.year, selectedDate.month, selectedDate.day),
+    [selectedDate.year, selectedDate.month, selectedDate.day]
+  );
   const dateStr = getDateString(selectedDateObj);
   const isSelectedDateToday = isToday(selectedDateObj);
-  const dayTasks = useMemo(() => tasks[dateStr] || [], [tasks, dateStr]);
+  const dayTasks = useMemo(() => {
+    const existingTasks = tasks[dateStr] || [];
+    const recurringInstances = [];
+    const currentDateObj = new Date(selectedDate.year, selectedDate.month, selectedDate.day);
+    logger.log("[dayTasks] Calculating dayTasks with recurring instances", {
+      dateStr,
+      existingTaskCount: existingTasks.length,
+      existingTasks: existingTasks.map((t) => ({
+        id: t.id,
+        title: t.title,
+        state: t.state,
+        isRecurringInstance: t.isRecurringInstance,
+        recurringParentId: t.recurringParentId,
+        hasRecurrence: !!t.recurrence
+      }))
+    });
+    for (const [taskDate, taskList] of Object.entries(tasks)) {
+      for (const task of taskList) {
+        if (task.recurrence && !task.isRecurringInstance) {
+          if (recurringTaskService.shouldTaskGenerateForDate(task, currentDateObj)) {
+            const instanceExists = existingTasks.some(
+              (t) => t.recurringParentId === task.id
+            );
+            if (!instanceExists) {
+              const instance = recurringTaskService.generateRecurringInstance(
+                task,
+                currentDateObj
+              );
+              logger.log("[dayTasks] Generated recurring instance", {
+                instanceId: instance.id,
+                instanceTitle: instance.title,
+                parentId: task.id,
+                parentDate: taskDate,
+                targetDate: dateStr
+              });
+              recurringInstances.push(instance);
+            } else {
+              logger.log("[dayTasks] Instance already exists for parent", {
+                parentId: task.id,
+                parentTitle: task.title,
+                targetDate: dateStr
+              });
+            }
+          }
+        }
+      }
+    }
+    logger.log("[dayTasks] Recurring instances generated", {
+      dateStr,
+      recurringInstanceCount: recurringInstances.length,
+      totalTasks: existingTasks.length + recurringInstances.length
+    });
+    return [...existingTasks, ...recurringInstances];
+  }, [tasks, dateStr, selectedDate.year, selectedDate.month, selectedDate.day]);
   const stats = taskService.getTaskStats(tasks, dateStr);
   const isFocused = activePane === "tasks" && !isModalOpen;
   const flatTasks = useMemo(() => {
@@ -2921,9 +3528,20 @@ var TasksPane = () => {
       return prev;
     });
   }, [dayTasks]);
+  useEffect8(() => {
+    logger.log("[TasksPane] Edit mode or input mode changed", {
+      editMode,
+      isInputMode,
+      parentTaskId,
+      editValue,
+      isModalOpen,
+      isFocused
+    });
+  }, [editMode, isInputMode, parentTaskId, editValue, isModalOpen, isFocused]);
   useEffect8(() => {
     setSelectedIndex(0);
     setEditMode("none");
+    setEditingTaskId(null);
   }, [dateStr]);
   useEffect8(() => {
     if (selectedIndex >= flatTasks.length && flatTasks.length > 0) {
@@ -2943,6 +3561,240 @@ var TasksPane = () => {
   useEffect8(() => {
     setScrollOffset(0);
   }, [dateStr]);
+  const isRecurringTask = (task) => {
+    return !!(task.recurrence || task.isRecurringInstance);
+  };
+  const findRootParent = (task) => {
+    if (!task.parentId) {
+      return task;
+    }
+    for (const taskList of Object.values(tasks)) {
+      for (const potentialParent of taskList) {
+        if (potentialParent.id === task.parentId) {
+          return findRootParent(potentialParent);
+        }
+        const foundInChildren = findInChildren(potentialParent.children, task.parentId);
+        if (foundInChildren) {
+          return findRootParent(foundInChildren);
+        }
+      }
+    }
+    return null;
+  };
+  const findInChildren = (children, id) => {
+    for (const child of children) {
+      if (child.id === id) {
+        return child;
+      }
+      const found = findInChildren(child.children, id);
+      if (found) {
+        return found;
+      }
+    }
+    return null;
+  };
+  const hasRecurringAncestor = (task) => {
+    const root = findRootParent(task);
+    return root ? isRecurringTask(root) : false;
+  };
+  const executePendingAction = (action, thisOnly) => {
+    if (!action) return;
+    const task = flatTasks.find((ft) => ft.task.id === action.taskId)?.task;
+    if (!task) return;
+    logger.log("[TasksPane] executePendingAction called", {
+      action: action.action,
+      thisOnly,
+      taskId: action.taskId,
+      currentEditMode: editMode,
+      currentIsInputMode: isInputMode
+    });
+    switch (action.action) {
+      case "delete":
+        performDelete(action.taskId, task, thisOnly);
+        break;
+      case "edit":
+        performEdit(action.taskId, task, thisOnly);
+        break;
+    }
+    logger.log("[TasksPane] executePendingAction completed", {
+      newEditMode: editMode,
+      newIsInputMode: isInputMode
+    });
+  };
+  const performDelete = (taskId, task, thisOnly) => {
+    try {
+      pushUndoableAction("TASK_DELETE");
+      if (thisOnly) {
+        let updated = tasks;
+        const isMaterialized = Object.values(tasks).some(
+          (taskList) => findTaskById(taskList, taskId)
+        );
+        if (isMaterialized) {
+          updated = taskService.deleteTask(tasks, taskId);
+        }
+        if (task.isRecurringInstance && task.recurringParentId) {
+          updated = taskService.excludeRecurringInstance(updated, task.recurringParentId, dateStr);
+        } else if (task.recurrence) {
+          updated = taskService.excludeRecurringInstance(updated, taskId, dateStr);
+        }
+        setTasks(updated);
+        const updatedTimeline = timelineService.removeEventsByTaskId(
+          timeline,
+          taskId
+        );
+        setTimeline(updatedTimeline);
+      } else {
+        const parentIdToDelete = task.recurringParentId || taskId;
+        const updated = taskService.deleteTask(tasks, parentIdToDelete);
+        setTasks(updated);
+        const updatedTimeline = timelineService.removeEventsByTaskId(
+          timeline,
+          taskId
+        );
+        if (task.recurringParentId) {
+          const parentTimeline = timelineService.removeEventsByTaskId(updatedTimeline, task.recurringParentId);
+          setTimeline(parentTimeline);
+        } else {
+          setTimeline(updatedTimeline);
+        }
+      }
+    } catch (err) {
+      console.error("Error deleting task:", err);
+    }
+  };
+  const performEdit = (taskId, task, thisOnly) => {
+    if (thisOnly || task.isRecurringInstance) {
+      setEditMode("edit");
+      setEditValue(task.title);
+      setIsInputMode(true);
+    } else {
+      setEditMode("edit");
+      setEditValue(task.title);
+      setIsInputMode(true);
+    }
+  };
+  const performStateChange = (taskId, task, newState, thisOnly) => {
+    logger.log("[performStateChange] Called", {
+      taskId,
+      taskTitle: task.title,
+      taskDate: task.date,
+      previousState: task.state,
+      newState,
+      thisOnly,
+      isRecurringInstance: task.isRecurringInstance,
+      recurringParentId: task.recurringParentId,
+      hasRecurrence: !!task.recurrence,
+      parentId: task.parentId
+    });
+    try {
+      pushUndoableAction("TASK_UPDATE");
+      const previousState = task.state;
+      if (task.isRecurringInstance && task.recurringParentId) {
+        const existingTasks = tasks[task.date] || [];
+        const taskExists = existingTasks.some((t) => t.id === taskId);
+        if (!taskExists) {
+          logger.log("[performStateChange] Materializing recurring instance", {
+            taskId,
+            taskDate: task.date
+          });
+          const materializedTask = {
+            ...task,
+            state: newState,
+            endTime: ["completed", "delegated", "delayed"].includes(newState) ? /* @__PURE__ */ new Date() : void 0,
+            updatedAt: /* @__PURE__ */ new Date()
+          };
+          const updated = {
+            ...tasks,
+            [task.date]: [...existingTasks, materializedTask]
+          };
+          logger.log("[performStateChange] Materialized task added to tasks", {
+            taskId,
+            date: task.date,
+            tasksForDate: updated[task.date].length
+          });
+          setTasks(updated);
+        } else {
+          logger.log("[performStateChange] Task already materialized, updating normally", {
+            taskId,
+            newState
+          });
+          const updated = taskService.changeTaskState(
+            tasks,
+            taskId,
+            newState
+          );
+          logger.log("[performStateChange] Task state updated, setting tasks", {
+            taskId,
+            updatedTasksKeys: Object.keys(updated),
+            tasksForDate: updated[task.date]?.length || 0
+          });
+          setTasks(updated);
+        }
+      } else {
+        logger.log("[performStateChange] Calling taskService.changeTaskState", {
+          taskId,
+          newState
+        });
+        const updated = taskService.changeTaskState(
+          tasks,
+          taskId,
+          newState
+        );
+        logger.log("[performStateChange] Task state updated, setting tasks", {
+          taskId,
+          updatedTasksKeys: Object.keys(updated),
+          tasksForDate: updated[task.date]?.length || 0
+        });
+        setTasks(updated);
+      }
+      if (newState === "todo") {
+        const eventTypeToRemove = {
+          todo: "started" /* STARTED */,
+          // shouldn't happen
+          completed: "completed" /* COMPLETED */,
+          delegated: "delegated" /* DELEGATED */,
+          delayed: "delayed" /* DELAYED */
+        };
+        const updatedTimeline = timelineService.removeLastEventByType(
+          timeline,
+          taskId,
+          eventTypeToRemove[previousState]
+        );
+        setTimeline(updatedTimeline);
+        logger.log("[performStateChange] Toggled back to todo, removed timeline event");
+      } else if (isSelectedDateToday) {
+        const eventTypeMap = {
+          todo: "started" /* STARTED */,
+          // shouldn't happen
+          completed: "completed" /* COMPLETED */,
+          delegated: "delegated" /* DELEGATED */,
+          delayed: "delayed" /* DELAYED */
+        };
+        const event = timelineService.createEvent(
+          taskId,
+          task.title,
+          eventTypeMap[newState],
+          /* @__PURE__ */ new Date(),
+          previousState,
+          newState
+        );
+        const updatedTimeline = timelineService.addEvent(timeline, event);
+        setTimeline(updatedTimeline);
+        logger.log("[performStateChange] Created timeline event for today", {
+          eventType: eventTypeMap[newState]
+        });
+      } else {
+        logger.log("[performStateChange] Not today, skipping timeline event", {
+          isSelectedDateToday,
+          selectedDate: dateStr
+        });
+      }
+      logger.log("[performStateChange] Completed successfully");
+    } catch (err) {
+      logger.log("[performStateChange] Error", { error: err });
+      console.error("Error changing task state:", err);
+    }
+  };
   const handleAddTask = () => {
     setEditMode("add");
     setEditValue("");
@@ -2952,6 +3804,7 @@ var TasksPane = () => {
     if (selectedTask) {
       setEditMode("edit");
       setEditValue(selectedTask.title);
+      setEditingTaskId(selectedTask.id);
       setIsInputMode(true);
     }
   };
@@ -2965,73 +3818,266 @@ var TasksPane = () => {
     }
   };
   const handleDeleteTask = () => {
-    if (selectedTaskId) {
-      try {
-        pushUndoableAction("TASK_DELETE");
-        const updated = taskService.deleteTask(tasks, selectedTaskId);
-        setTasks(updated);
-        const updatedTimeline = timelineService.removeEventsByTaskId(
-          timeline,
-          selectedTaskId
-        );
-        setTimeline(updatedTimeline);
-      } catch (err) {
-        console.error("Error deleting task:", err);
-      }
-    }
-  };
-  const handleChangeState = (newState) => {
     if (selectedTaskId && selectedTask) {
-      try {
-        pushUndoableAction("TASK_UPDATE");
-        const previousState = selectedTask.state;
-        const updated = taskService.changeTaskState(
-          tasks,
-          selectedTaskId,
-          newState
-        );
-        setTasks(updated);
-        if (newState === "todo") {
-          const eventTypeToRemove = {
-            todo: "started" /* STARTED */,
-            // shouldn't happen
-            completed: "completed" /* COMPLETED */,
-            delegated: "delegated" /* DELEGATED */,
-            delayed: "delayed" /* DELAYED */
-          };
-          const updatedTimeline = timelineService.removeLastEventByType(
+      logger.log("handleDeleteTask called", {
+        taskId: selectedTaskId,
+        isRecurring: isRecurringTask(selectedTask),
+        hasRecurrence: !!selectedTask.recurrence,
+        isInstance: !!selectedTask.isRecurringInstance,
+        hasRecurringAncestor: hasRecurringAncestor(selectedTask)
+      });
+      if (hasRecurringAncestor(selectedTask)) {
+        const action = { action: "delete", taskId: selectedTaskId };
+        const savedIndex = selectedIndex;
+        const rootParent = findRootParent(selectedTask);
+        setPendingAction(action);
+        setRecurringEditConfig({
+          taskId: selectedTaskId,
+          taskTitle: selectedTask.title,
+          actionType: "delete",
+          onConfirm: (choice) => {
+            logger.log("Recurring delete confirmed", { choice, action });
+            pushUndoableAction("TASK_DELETE");
+            if (choice === "this") {
+              let updated = tasks;
+              const isMaterialized = Object.values(tasks).some(
+                (taskList) => findTaskById(taskList, selectedTaskId)
+              );
+              if (isMaterialized) {
+                updated = taskService.deleteTask(tasks, selectedTaskId);
+              }
+              if (selectedTask.isRecurringInstance && selectedTask.recurringParentId) {
+                updated = taskService.excludeRecurringInstance(updated, selectedTask.recurringParentId, dateStr);
+              } else if (selectedTask.recurrence) {
+                updated = taskService.excludeRecurringInstance(updated, selectedTaskId, dateStr);
+              }
+              setTasks(updated);
+              const updatedTimeline = timelineService.removeEventsByTaskId(
+                timeline,
+                selectedTaskId
+              );
+              setTimeline(updatedTimeline);
+            } else if (choice === "all" && rootParent) {
+              if (selectedTask.parentId) {
+                const deleteSubtaskFromTree = (task, targetId) => {
+                  return {
+                    ...task,
+                    children: task.children.filter((child) => child.id !== targetId).map((child) => deleteSubtaskFromTree(child, targetId))
+                  };
+                };
+                let updated = { ...tasks };
+                for (const [date, taskList] of Object.entries(tasks)) {
+                  const rootIndex = taskList.findIndex((t) => t.id === rootParent.id);
+                  if (rootIndex !== -1) {
+                    const updatedRoot = deleteSubtaskFromTree(taskList[rootIndex], selectedTaskId);
+                    updated[date] = [
+                      ...taskList.slice(0, rootIndex),
+                      updatedRoot,
+                      ...taskList.slice(rootIndex + 1)
+                    ];
+                    break;
+                  }
+                }
+                setTasks(updated);
+              } else {
+                const parentIdToDelete = selectedTask.recurringParentId || selectedTaskId;
+                const updated = taskService.deleteTask(tasks, parentIdToDelete);
+                setTasks(updated);
+              }
+              const updatedTimeline = timelineService.removeEventsByTaskId(
+                timeline,
+                selectedTaskId
+              );
+              if (selectedTask.recurringParentId) {
+                const parentTimeline = timelineService.removeEventsByTaskId(updatedTimeline, selectedTask.recurringParentId);
+                setTimeline(parentTimeline);
+              } else {
+                setTimeline(updatedTimeline);
+              }
+            } else if (choice === "from-today" && rootParent) {
+              const todayDateObj = /* @__PURE__ */ new Date();
+              todayDateObj.setHours(0, 0, 0, 0);
+              if (selectedTask.parentId) {
+                const deleteSubtaskFromTree = (task, targetId) => {
+                  return {
+                    ...task,
+                    children: task.children.filter((child) => child.id !== targetId).map((child) => deleteSubtaskFromTree(child, targetId))
+                  };
+                };
+                let updated = { ...tasks };
+                for (const [date, taskList] of Object.entries(tasks)) {
+                  const rootIndex = taskList.findIndex((t) => t.id === rootParent.id);
+                  if (rootIndex !== -1) {
+                    const findSubtaskByTitlePath = (task, targetTask, path2 = []) => {
+                      if (task.title === targetTask.title && path2.length > 0) {
+                        return path2;
+                      }
+                      for (const child of task.children) {
+                        const result = findSubtaskByTitlePath(child, targetTask, [...path2, child.title]);
+                        if (result) return result;
+                      }
+                      return null;
+                    };
+                    const deleteByTitlePath = (task, titlePath2, currentDepth = 0) => {
+                      if (currentDepth >= titlePath2.length) return task;
+                      return {
+                        ...task,
+                        children: task.children.filter((child) => child.title !== titlePath2[currentDepth]).map((child) => deleteByTitlePath(child, titlePath2, currentDepth + 1))
+                      };
+                    };
+                    const titlePath = findSubtaskByTitlePath(taskList[rootIndex], selectedTask);
+                    if (titlePath) {
+                      const updatedRoot = deleteByTitlePath(taskList[rootIndex], titlePath);
+                      updated[date] = [
+                        ...taskList.slice(0, rootIndex),
+                        updatedRoot,
+                        ...taskList.slice(rootIndex + 1)
+                      ];
+                      logger.log("Deleting subtask from root parent by title path (from-today)", {
+                        rootParentId: rootParent.id,
+                        titlePath
+                      });
+                    } else {
+                      const updatedRoot = deleteSubtaskFromTree(taskList[rootIndex], selectedTaskId);
+                      updated[date] = [
+                        ...taskList.slice(0, rootIndex),
+                        updatedRoot,
+                        ...taskList.slice(rootIndex + 1)
+                      ];
+                      logger.log("Deleting subtask from root parent by ID (from-today)", {
+                        rootParentId: rootParent.id,
+                        subtaskId: selectedTaskId
+                      });
+                    }
+                    break;
+                  }
+                }
+                for (const [date, taskList] of Object.entries(updated)) {
+                  const dateObj = new Date(date);
+                  dateObj.setHours(0, 0, 0, 0);
+                  if (dateObj >= todayDateObj) {
+                    let hasChanges = false;
+                    const updatedTaskList = taskList.map((task) => {
+                      if (task.isRecurringInstance && task.recurringParentId === rootParent.id) {
+                        logger.log("Deleting subtask from materialized instance (from-today)", {
+                          instanceId: task.id,
+                          instanceDate: date,
+                          subtaskTitle: selectedTask.title
+                        });
+                        hasChanges = true;
+                        const deleteByTitle = (t, targetTitle) => {
+                          return {
+                            ...t,
+                            children: t.children.filter((child) => child.title !== targetTitle).map((child) => deleteByTitle(child, targetTitle))
+                          };
+                        };
+                        return deleteByTitle(task, selectedTask.title);
+                      }
+                      return task;
+                    });
+                    if (hasChanges) {
+                      updated[date] = updatedTaskList;
+                    }
+                  }
+                }
+                setTasks(updated);
+              } else {
+                let updated = { ...tasks };
+                const isMaterialized = Object.values(tasks).some(
+                  (taskList) => taskList.some((t) => t.id === selectedTaskId)
+                );
+                if (isMaterialized) {
+                  updated = taskService.deleteTask(tasks, selectedTaskId);
+                  logger.log("Deleting materialized root task (from-today)", {
+                    taskId: selectedTaskId
+                  });
+                } else {
+                  const parentId = selectedTask.recurringParentId;
+                  if (parentId) {
+                    updated = taskService.deleteTask(tasks, parentId);
+                    logger.log("Deleting parent recurring task (from-today)", {
+                      parentId,
+                      ephemeralTaskId: selectedTaskId
+                    });
+                  }
+                }
+                const recurringParentToDelete = selectedTask.recurringParentId || selectedTaskId;
+                for (const [date, taskList] of Object.entries(updated)) {
+                  const dateObj = new Date(date);
+                  dateObj.setHours(0, 0, 0, 0);
+                  if (dateObj >= todayDateObj) {
+                    const filteredTaskList = taskList.filter((task) => {
+                      if (task.isRecurringInstance && task.recurringParentId === recurringParentToDelete) {
+                        logger.log("Deleting materialized instance (from-today)", {
+                          instanceId: task.id,
+                          instanceDate: date
+                        });
+                        return false;
+                      }
+                      return true;
+                    });
+                    if (filteredTaskList.length !== taskList.length) {
+                      updated[date] = filteredTaskList;
+                    }
+                  }
+                }
+                setTasks(updated);
+              }
+              const updatedTimeline = timelineService.removeEventsByTaskId(
+                timeline,
+                selectedTaskId
+              );
+              setTimeline(updatedTimeline);
+            }
+            setPendingAction(null);
+          }
+        });
+        setShowRecurringEditDialog(true);
+      } else {
+        logger.log("Not recurring, deleting directly");
+        try {
+          pushUndoableAction("TASK_DELETE");
+          const updated = taskService.deleteTask(tasks, selectedTaskId);
+          setTasks(updated);
+          const updatedTimeline = timelineService.removeEventsByTaskId(
             timeline,
-            selectedTaskId,
-            eventTypeToRemove[previousState]
+            selectedTaskId
           );
           setTimeline(updatedTimeline);
-        } else if (isSelectedDateToday) {
-          const eventTypeMap = {
-            todo: "started" /* STARTED */,
-            // shouldn't happen
-            completed: "completed" /* COMPLETED */,
-            delegated: "delegated" /* DELEGATED */,
-            delayed: "delayed" /* DELAYED */
-          };
-          const event = timelineService.createEvent(
-            selectedTaskId,
-            selectedTask.title,
-            eventTypeMap[newState],
-            /* @__PURE__ */ new Date(),
-            previousState,
-            newState
-          );
-          const updatedTimeline = timelineService.addEvent(timeline, event);
-          setTimeline(updatedTimeline);
+        } catch (err) {
+          console.error("Error deleting task:", err);
         }
-      } catch (err) {
-        console.error("Error changing task state:", err);
       }
     }
   };
+  const handleChangeState = (newState) => {
+    if (selectedTaskId && selectedTask) {
+      logger.log("[handleChangeState] Called", {
+        selectedTaskId,
+        taskTitle: selectedTask.title,
+        taskDate: selectedTask.date,
+        currentState: selectedTask.state,
+        newState,
+        isRecurringInstance: selectedTask.isRecurringInstance,
+        recurringParentId: selectedTask.recurringParentId,
+        hasRecurrence: !!selectedTask.recurrence,
+        parentId: selectedTask.parentId
+      });
+      performStateChange(selectedTaskId, selectedTask, newState, true);
+    }
+  };
   const handleToggleComplete = () => {
     if (selectedTask) {
       const newState = selectedTask.state === "completed" ? "todo" : "completed";
+      logger.log("[handleToggleComplete] Called", {
+        selectedTaskId,
+        taskTitle: selectedTask.title,
+        taskDate: selectedTask.date,
+        currentState: selectedTask.state,
+        newState,
+        isRecurringInstance: selectedTask.isRecurringInstance,
+        recurringParentId: selectedTask.recurringParentId
+      });
       handleChangeState(newState);
     }
   };
@@ -3041,6 +4087,7 @@ var TasksPane = () => {
       setEditMode("none");
       setEditValue("");
       setParentTaskId(null);
+      setEditingTaskId(null);
       setIsInputMode(false);
       return;
     }
@@ -3054,35 +4101,335 @@ var TasksPane = () => {
         };
         setTasks(newTasks);
         setSelectedIndex(flatTasks.length);
+        setEditMode("none");
+        setEditValue("");
+        setParentTaskId(null);
+        setEditingTaskId(null);
+        setIsInputMode(false);
       } else if (editMode === "addSubtask" && parentTaskId) {
-        pushUndoableAction("TASK_ADD");
-        const updated = taskService.addSubtask(tasks, parentTaskId, trimmed);
-        setTasks(updated);
-        const parentIndex = flatTasks.findIndex(
-          (ft) => ft.task.id === parentTaskId
-        );
-        if (parentIndex !== -1) {
-          setSelectedIndex(parentIndex + 1);
+        const parentTask = flatTasks.find((ft) => ft.task.id === parentTaskId)?.task;
+        if (parentTask && isRecurringTask(parentTask)) {
+          const savedValue = trimmed;
+          const savedParentId = parentTaskId;
+          const savedIndex = selectedIndex;
+          setRecurringEditConfig({
+            taskId: savedParentId,
+            taskTitle: parentTask.title,
+            actionType: "add-subtask",
+            onConfirm: (choice) => {
+              logger.log("Recurring subtask save confirmed", { choice, newSubtask: savedValue });
+              pushUndoableAction("TASK_ADD");
+              if (choice === "this") {
+                const existingTasks = tasks[dateStr] || [];
+                const taskExists = existingTasks.some((t) => t.id === savedParentId);
+                if (taskExists) {
+                  logger.log("Adding subtask to already materialized task (this only)", {
+                    parentId: savedParentId,
+                    subtaskTitle: savedValue
+                  });
+                  const updated = taskService.addSubtask(tasks, savedParentId, savedValue);
+                  setTasks(updated);
+                } else {
+                  const ephemeralParent = dayTasks.find((t) => t.id === savedParentId);
+                  if (ephemeralParent && ephemeralParent.isRecurringInstance) {
+                    logger.log("Materializing ephemeral recurring instance for subtask addition (this only)", {
+                      parentId: savedParentId,
+                      recurringParentId: ephemeralParent.recurringParentId,
+                      subtaskTitle: savedValue
+                    });
+                    const newSubtask = taskService.createTask(savedValue, dateStr);
+                    const materializedTask = {
+                      ...ephemeralParent,
+                      children: [...ephemeralParent.children, { ...newSubtask, parentId: savedParentId }]
+                    };
+                    const updated = {
+                      ...tasks,
+                      [dateStr]: [...existingTasks, materializedTask]
+                    };
+                    setTasks(updated);
+                  } else if (ephemeralParent) {
+                    logger.log("Parent is original recurring task, adding subtask (this only - but will affect template)", {
+                      parentId: savedParentId,
+                      subtaskTitle: savedValue
+                    });
+                    const updated = taskService.addSubtask(tasks, savedParentId, savedValue);
+                    setTasks(updated);
+                  } else {
+                    logger.log("Parent task not found in ephemeral dayTasks", {
+                      parentId: savedParentId
+                    });
+                  }
+                }
+              } else if (choice === "all") {
+                const recurringParentId = parentTask.recurringParentId || savedParentId;
+                let updated = taskService.addSubtask(tasks, recurringParentId, savedValue);
+                logger.log("Adding subtask to parent and materialized instances", {
+                  recurringParentId,
+                  subtaskTitle: savedValue
+                });
+                for (const [date, taskList] of Object.entries(updated)) {
+                  for (let i = 0; i < taskList.length; i++) {
+                    const task = taskList[i];
+                    if (task.isRecurringInstance && task.recurringParentId === recurringParentId) {
+                      logger.log("Adding subtask to materialized instance", {
+                        instanceId: task.id,
+                        instanceDate: date,
+                        subtaskTitle: savedValue
+                      });
+                      updated = taskService.addSubtask(updated, task.id, savedValue);
+                    }
+                  }
+                }
+                setTasks(updated);
+              } else if (choice === "from-today") {
+                const todayDateObj = /* @__PURE__ */ new Date();
+                todayDateObj.setHours(0, 0, 0, 0);
+                const recurringParentId = parentTask.recurringParentId || savedParentId;
+                let updated = taskService.addSubtask(tasks, recurringParentId, savedValue);
+                logger.log("Adding subtask to parent and future materialized instances (from-today)", {
+                  recurringParentId,
+                  subtaskTitle: savedValue
+                });
+                for (const [date, taskList] of Object.entries(updated)) {
+                  const dateObj = new Date(date);
+                  dateObj.setHours(0, 0, 0, 0);
+                  if (dateObj >= todayDateObj) {
+                    for (let i = 0; i < taskList.length; i++) {
+                      const task = taskList[i];
+                      if (task.isRecurringInstance && task.recurringParentId === recurringParentId) {
+                        logger.log("Adding subtask to materialized instance (from-today)", {
+                          instanceId: task.id,
+                          instanceDate: date,
+                          subtaskTitle: savedValue
+                        });
+                        updated = taskService.addSubtask(updated, task.id, savedValue);
+                      }
+                    }
+                  }
+                }
+                setTasks(updated);
+              }
+              setTimeout(() => {
+                const parentIndex = flatTasks.findIndex(
+                  (ft) => ft.task.id === savedParentId
+                );
+                if (parentIndex !== -1) {
+                  setSelectedIndex(parentIndex + 1);
+                }
+                setEditMode("none");
+                setEditValue("");
+                setParentTaskId(null);
+                setEditingTaskId(null);
+                setIsInputMode(false);
+              }, 0);
+            }
+          });
+          setShowRecurringEditDialog(true);
+        } else {
+          pushUndoableAction("TASK_ADD");
+          const updated = taskService.addSubtask(tasks, parentTaskId, trimmed);
+          setTasks(updated);
+          const parentIndex = flatTasks.findIndex(
+            (ft) => ft.task.id === parentTaskId
+          );
+          if (parentIndex !== -1) {
+            setSelectedIndex(parentIndex + 1);
+          }
+          setEditMode("none");
+          setEditValue("");
+          setParentTaskId(null);
+          setEditingTaskId(null);
+          setIsInputMode(false);
+        }
+      } else if (editMode === "edit" && editingTaskId) {
+        const taskBeingEdited = flatTasks.find((ft) => ft.task.id === editingTaskId)?.task;
+        if (taskBeingEdited && hasRecurringAncestor(taskBeingEdited)) {
+          const savedValue = trimmed;
+          const savedTaskId = editingTaskId;
+          const savedIndex = selectedIndex;
+          const rootParent = findRootParent(taskBeingEdited);
+          setRecurringEditConfig({
+            taskId: savedTaskId,
+            taskTitle: taskBeingEdited.title,
+            actionType: "edit",
+            onConfirm: (choice) => {
+              logger.log("Recurring edit save confirmed", { choice, newTitle: savedValue });
+              pushUndoableAction("TASK_UPDATE");
+              if (choice === "this") {
+                const updated = taskService.updateTask(tasks, savedTaskId, {
+                  title: savedValue
+                });
+                setTasks(updated);
+              } else if (choice === "all" && rootParent) {
+                let updated = { ...tasks };
+                if (taskBeingEdited.parentId) {
+                  const updateSubtaskInTree = (task, targetId, newTitle) => {
+                    if (task.id === targetId) {
+                      return { ...task, title: newTitle, updatedAt: /* @__PURE__ */ new Date() };
+                    }
+                    return {
+                      ...task,
+                      children: task.children.map((child) => updateSubtaskInTree(child, targetId, newTitle))
+                    };
+                  };
+                  logger.log("Updating subtask in root parent and materialized instances", {
+                    subtaskId: savedTaskId,
+                    newTitle: savedValue,
+                    rootParentId: rootParent.id
+                  });
+                  for (const [date, taskList] of Object.entries(tasks)) {
+                    const rootIndex = taskList.findIndex((t) => t.id === rootParent.id);
+                    if (rootIndex !== -1) {
+                      const updatedRoot = updateSubtaskInTree(taskList[rootIndex], savedTaskId, savedValue);
+                      updated[date] = [
+                        ...taskList.slice(0, rootIndex),
+                        updatedRoot,
+                        ...taskList.slice(rootIndex + 1)
+                      ];
+                      break;
+                    }
+                  }
+                  for (const [date, taskList] of Object.entries(updated)) {
+                    let hasChanges = false;
+                    const updatedTaskList = taskList.map((task) => {
+                      if (task.isRecurringInstance && task.recurringParentId === rootParent.id) {
+                        logger.log("Updating subtask in materialized instance", {
+                          instanceId: task.id,
+                          instanceDate: date,
+                          subtaskId: savedTaskId,
+                          newTitle: savedValue
+                        });
+                        hasChanges = true;
+                        return updateSubtaskInTree(task, savedTaskId, savedValue);
+                      }
+                      return task;
+                    });
+                    if (hasChanges) {
+                      updated[date] = updatedTaskList;
+                    }
+                  }
+                  setTasks(updated);
+                } else {
+                  const updated2 = taskService.updateTask(tasks, savedTaskId, {
+                    title: savedValue
+                  });
+                  setTasks(updated2);
+                }
+              } else if (choice === "from-today" && rootParent) {
+                const todayDateObj = /* @__PURE__ */ new Date();
+                todayDateObj.setHours(0, 0, 0, 0);
+                let updated = { ...tasks };
+                if (taskBeingEdited.parentId) {
+                  const updateSubtaskInTree = (task, targetId, newTitle) => {
+                    if (task.id === targetId) {
+                      return { ...task, title: newTitle, updatedAt: /* @__PURE__ */ new Date() };
+                    }
+                    return {
+                      ...task,
+                      children: task.children.map((child) => updateSubtaskInTree(child, targetId, newTitle))
+                    };
+                  };
+                  logger.log("Updating subtask in root parent and future materialized instances (from-today)", {
+                    subtaskId: savedTaskId,
+                    newTitle: savedValue,
+                    rootParentId: rootParent.id
+                  });
+                  for (const [date, taskList] of Object.entries(tasks)) {
+                    const rootIndex = taskList.findIndex((t) => t.id === rootParent.id);
+                    if (rootIndex !== -1) {
+                      const updatedRoot = updateSubtaskInTree(taskList[rootIndex], savedTaskId, savedValue);
+                      updated[date] = [
+                        ...taskList.slice(0, rootIndex),
+                        updatedRoot,
+                        ...taskList.slice(rootIndex + 1)
+                      ];
+                      break;
+                    }
+                  }
+                  for (const [date, taskList] of Object.entries(updated)) {
+                    const dateObj = new Date(date);
+                    dateObj.setHours(0, 0, 0, 0);
+                    if (dateObj >= todayDateObj) {
+                      let hasChanges = false;
+                      const updatedTaskList = taskList.map((task) => {
+                        if (task.isRecurringInstance && task.recurringParentId === rootParent.id) {
+                          logger.log("Updating subtask in materialized instance (from-today)", {
+                            instanceId: task.id,
+                            instanceDate: date,
+                            subtaskId: savedTaskId,
+                            newTitle: savedValue
+                          });
+                          hasChanges = true;
+                          return updateSubtaskInTree(task, savedTaskId, savedValue);
+                        }
+                        return task;
+                      });
+                      if (hasChanges) {
+                        updated[date] = updatedTaskList;
+                      }
+                    }
+                  }
+                  setTasks(updated);
+                } else {
+                  let updated2 = taskService.updateTask(tasks, savedTaskId, {
+                    title: savedValue
+                  });
+                  for (const [date, taskList] of Object.entries(updated2)) {
+                    const dateObj = new Date(date);
+                    dateObj.setHours(0, 0, 0, 0);
+                    if (dateObj >= todayDateObj) {
+                      let hasChanges = false;
+                      const updatedTaskList = taskList.map((task) => {
+                        if (task.isRecurringInstance && task.recurringParentId === savedTaskId) {
+                          logger.log("Updating materialized instance (from-today)", {
+                            instanceId: task.id,
+                            instanceDate: date,
+                            newTitle: savedValue
+                          });
+                          hasChanges = true;
+                          return { ...task, title: savedValue, updatedAt: /* @__PURE__ */ new Date() };
+                        }
+                        return task;
+                      });
+                      if (hasChanges) {
+                        updated2[date] = updatedTaskList;
+                      }
+                    }
+                  }
+                  setTasks(updated2);
+                }
+              }
+              setTimeout(() => {
+                setEditMode("none");
+                setEditValue("");
+                setEditingTaskId(null);
+                setIsInputMode(false);
+                setSelectedIndex(savedIndex);
+              }, 0);
+            }
+          });
+          setShowRecurringEditDialog(true);
+        } else {
+          pushUndoableAction("TASK_UPDATE");
+          const updated = taskService.updateTask(tasks, editingTaskId, {
+            title: trimmed
+          });
+          setTasks(updated);
+          setEditMode("none");
+          setEditValue("");
+          setEditingTaskId(null);
+          setIsInputMode(false);
         }
-      } else if (editMode === "edit" && selectedTaskId) {
-        pushUndoableAction("TASK_UPDATE");
-        const updated = taskService.updateTask(tasks, selectedTaskId, {
-          title: trimmed
-        });
-        setTasks(updated);
       }
     } catch (err) {
       console.error("Error saving task:", err);
     }
-    setEditMode("none");
-    setEditValue("");
-    setParentTaskId(null);
-    setIsInputMode(false);
   };
   const handleCancelEdit = () => {
     setEditMode("none");
     setEditValue("");
     setParentTaskId(null);
+    setEditingTaskId(null);
     setIsInputMode(false);
   };
   const handleToggleExpand = () => {
@@ -3215,6 +4562,15 @@ var TasksPane = () => {
         }
         return;
       }
+      if (input === "r" && selectedTask) {
+        if (selectedTask.parentId) {
+          logger.log("Cannot mark nested task as recurring", { taskId: selectedTask.id, parentId: selectedTask.parentId });
+          return;
+        }
+        setRecurringTaskId(selectedTaskId);
+        setShowRecurringTaskDialog(true);
+        return;
+      }
       if (key.return && selectedTask) {
         handleToggleExpand();
         return;
@@ -3309,7 +4665,7 @@ var TasksPane = () => {
             }
           ),
           /* @__PURE__ */ jsx14(Text7, { children: " " }),
-          task.children.length > 0 && /* @__PURE__ */ jsxs9(Fragment, { children: [
+          task.children.length > 0 && /* @__PURE__ */ jsxs9(Fragment2, { children: [
             /* @__PURE__ */ jsx14(Text7, { color: theme.colors.foreground, children: isExpanded ? "\u25BC" : "\u25B6" }),
             /* @__PURE__ */ jsx14(Text7, { children: " " })
           ] }),
@@ -3322,6 +4678,16 @@ var TasksPane = () => {
               children: task.title
             }
           ),
+          task.recurrence && /* @__PURE__ */ jsxs9(
+            Text7,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.timelineEventStarted,
+              children: [
+                " ",
+                "\u21BA"
+              ]
+            }
+          ),
           task.startTime && !task.endTime && /* @__PURE__ */ jsxs9(
             Text7,
             {
@@ -3349,6 +4715,7 @@ var TasksPane = () => {
           { key: "D", description: "delegate" },
           { key: "x", description: "delay" },
           { key: "s", description: "start" },
+          { key: "r", description: "recurring" },
           { key: "\u2190/\u2192", description: "collapse/expand" },
           { key: "Cmd+\u2190/\u2192", description: "all" }
         ]
@@ -3576,7 +4943,7 @@ var TimelinePane = () => {
 };
 
 // src/components/common/HelpDialog.tsx
-import { Box as Box13, Text as Text10 } from "ink";
+import { Box as Box13, Text as Text10, useInput as useInput6 } from "ink";
 
 // src/components/common/Modal.tsx
 import { Box as Box12, useStdout as useStdout3 } from "ink";
@@ -3630,12 +4997,23 @@ var Modal = ({ children }) => {
 };
 
 // src/components/common/HelpDialog.tsx
-import { Fragment as Fragment2, jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx19, jsxs as jsxs12 } from "react/jsx-runtime";
 var HelpDialog = () => {
   const { theme } = useTheme();
+  const { setShowHelp, setShowSettingsDialog } = useApp();
+  useInput6((input, key) => {
+    if (key.escape || input === "?") {
+      setShowHelp(false);
+    }
+    if (key.ctrl && input === "s") {
+      setShowHelp(false);
+      setShowSettingsDialog(true);
+    }
+  }, { isActive: true });
   const shortcuts = [
     { key: "Ctrl+C (twice)", action: "Quit application" },
     { key: "Ctrl+U", action: "Undo last action" },
+    { key: "Ctrl+S", action: "Open settings" },
     { key: "?", action: "Toggle help dialog" },
     { key: "Shift+;", action: "Show month overview" },
     { key: "t", action: "Select theme" },
@@ -3658,11 +5036,22 @@ var HelpDialog = () => {
     { key: "s", action: "Start task" },
     { key: "D", action: "Mark delegated" },
     { key: "x", action: "Mark delayed/cancelled" },
+    { key: "r", action: "Make task recurring" },
     { key: "Enter", action: "Expand/collapse subtasks" },
     { key: "", action: "" },
     { key: "Timeline Pane", action: "" },
     { key: "j/k", action: "Scroll timeline" },
-    { key: "Shift+C", action: "Clear timeline" }
+    { key: "Shift+C", action: "Clear timeline" },
+    { key: "", action: "" },
+    { key: "Input Editing", action: "" },
+    { key: "\u2190/\u2192", action: "Move cursor left/right" },
+    { key: "Ctrl+\u2190/\u2192", action: "Move by word" },
+    { key: "Ctrl+A", action: "Move to start of line" },
+    { key: "Ctrl+E", action: "Move to end of line" },
+    { key: "Delete/Backspace", action: "Delete character" },
+    { key: "Ctrl+W", action: "Delete word before cursor" },
+    { key: "Ctrl+U", action: "Delete to start of line" },
+    { key: "Ctrl+K", action: "Delete to end of line" }
   ];
   return /* @__PURE__ */ jsx19(Modal, { children: /* @__PURE__ */ jsxs12(
     Box13,
@@ -3675,11 +5064,11 @@ var HelpDialog = () => {
       backgroundColor: theme.colors.modalBackground || theme.colors.background,
       children: [
         /* @__PURE__ */ jsx19(Text10, { bold: true, color: theme.colors.calendarHeader, children: "Keyboard Shortcuts" }),
-        /* @__PURE__ */ jsx19(Box13, { flexDirection: "column", marginTop: 1, children: shortcuts.map((item, idx) => /* @__PURE__ */ jsx19(Box13, { marginY: 0, children: item.key ? /* @__PURE__ */ jsxs12(Fragment2, { children: [
+        /* @__PURE__ */ jsx19(Box13, { flexDirection: "column", marginTop: 1, children: shortcuts.map((item, idx) => /* @__PURE__ */ jsx19(Box13, { marginY: 0, children: item.key ? /* @__PURE__ */ jsxs12(Fragment3, { children: [
           /* @__PURE__ */ jsx19(Box13, { width: 20, children: /* @__PURE__ */ jsx19(Text10, { color: theme.colors.timelineEventStarted, children: item.key }) }),
           /* @__PURE__ */ jsx19(Text10, { color: theme.colors.foreground, children: item.action })
         ] }) : /* @__PURE__ */ jsx19(Text10, { color: theme.colors.separator, children: "\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500" }) }, idx)) }),
-        /* @__PURE__ */ jsx19(Box13, { marginY: 1, children: /* @__PURE__ */ jsx19(Text10, { color: theme.colors.keyboardHint, dimColor: true, children: "Press '?' to close" }) })
+        /* @__PURE__ */ jsx19(Box13, { marginY: 1, children: /* @__PURE__ */ jsx19(Text10, { color: theme.colors.keyboardHint, dimColor: true, children: "Press '?' or Esc to close" }) })
       ]
     }
   ) });
@@ -3687,7 +5076,7 @@ var HelpDialog = () => {
 
 // src/components/common/ThemeDialog.tsx
 import { useState as useState9, useMemo as useMemo3, useEffect as useEffect10 } from "react";
-import { Box as Box14, Text as Text11, useInput as useInput6 } from "ink";
+import { Box as Box14, Text as Text11, useInput as useInput7 } from "ink";
 import { jsx as jsx20, jsxs as jsxs13 } from "react/jsx-runtime";
 var ThemeDialog = () => {
   const { theme, setTheme, themeName } = useTheme();
@@ -3731,7 +5120,7 @@ var ThemeDialog = () => {
   useEffect10(() => {
     setSelectedIndex(0);
   }, [searchQuery]);
-  useInput6(
+  useInput7(
     (input, key) => {
       if (key.escape) {
         setShowThemeDialog(false);
@@ -3842,10 +5231,299 @@ var ThemeDialog = () => {
   ) });
 };
 
+// src/components/common/SettingsDialog.tsx
+import { useState as useState10 } from "react";
+import { Box as Box15, Text as Text12, useInput as useInput8 } from "ink";
+import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
+var SettingsDialog = () => {
+  const { theme } = useTheme();
+  const { setShowSettingsDialog } = useApp();
+  const { data, save } = useStorage();
+  const [selectedIndex, setSelectedIndex] = useState10(0);
+  const settings = [
+    {
+      label: "Auto-move unfinished tasks to next day",
+      key: "autoMoveUnfinishedTasks",
+      value: data?.settings?.autoMoveUnfinishedTasks ?? true
+    }
+  ];
+  const toggleSetting = (key) => {
+    if (!data) return;
+    const newValue = !data.settings[key];
+    logger.log("Toggling setting", { key, newValue });
+    save({
+      ...data,
+      settings: {
+        ...data.settings,
+        [key]: newValue
+      }
+    });
+  };
+  useInput8(
+    (input, key) => {
+      if (key.escape) {
+        logger.log("Closing settings dialog");
+        setShowSettingsDialog(false);
+        return;
+      }
+      if (key.upArrow || input === "k") {
+        setSelectedIndex((prev) => prev > 0 ? prev - 1 : settings.length - 1);
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        setSelectedIndex((prev) => prev < settings.length - 1 ? prev + 1 : 0);
+        return;
+      }
+      if (key.return || input === " ") {
+        toggleSetting(settings[selectedIndex].key);
+        return;
+      }
+    },
+    { isActive: true }
+  );
+  return /* @__PURE__ */ jsx21(Modal, { children: /* @__PURE__ */ jsxs14(
+    Box15,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.helpDialogBorder,
+      paddingX: 2,
+      paddingY: 1,
+      width: 70,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx21(Text12, { bold: true, color: theme.colors.calendarHeader, underline: true, children: "Settings" }),
+        /* @__PURE__ */ jsx21(Box15, { flexDirection: "column", marginTop: 1, children: settings.map((setting, idx) => {
+          const isSelected = idx === selectedIndex;
+          const isEnabled = setting.value;
+          return /* @__PURE__ */ jsx21(Box15, { marginY: 0, children: /* @__PURE__ */ jsxs14(
+            Text12,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u279C " : "  ",
+                setting.label,
+                ": ",
+                /* @__PURE__ */ jsx21(
+                  Text12,
+                  {
+                    color: isEnabled ? theme.colors.taskStateCompleted : theme.colors.taskStateDelayed,
+                    children: isEnabled ? "ON" : "OFF"
+                  }
+                )
+              ]
+            }
+          ) }, setting.key);
+        }) }),
+        /* @__PURE__ */ jsx21(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx21(Text12, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2191/\u2193 or k/j to navigate \u2022 Space/Enter to toggle \u2022 Esc to close" }) })
+      ]
+    }
+  ) });
+};
+
+// src/components/common/RecurringTaskDialog.tsx
+import { useState as useState11 } from "react";
+import { Box as Box16, Text as Text13, useInput as useInput9 } from "ink";
+import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
+var RecurringTaskDialog = ({
+  onConfirm,
+  onCancel
+}) => {
+  const { theme } = useTheme();
+  const frequencies = [
+    { value: "daily", label: "Daily" },
+    { value: "weekdays", label: "Weekdays (Mon-Fri)" },
+    { value: "weekly", label: "Weekly" },
+    { value: "monthly", label: "Monthly" },
+    { value: "yearly", label: "Yearly" }
+  ];
+  const [selectedIndex, setSelectedIndex] = useState11(0);
+  useInput9(
+    (input, key) => {
+      if (key.escape) {
+        logger.log("Cancelling recurring task dialog");
+        onCancel();
+        return;
+      }
+      if (key.upArrow || input === "k") {
+        setSelectedIndex(
+          (prev) => prev > 0 ? prev - 1 : frequencies.length - 1
+        );
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        setSelectedIndex(
+          (prev) => prev < frequencies.length - 1 ? prev + 1 : 0
+        );
+        return;
+      }
+      if (key.return) {
+        const selectedFrequency = frequencies[selectedIndex].value;
+        const pattern = {
+          frequency: selectedFrequency
+        };
+        logger.log("Setting task recurrence", { frequency: selectedFrequency });
+        onConfirm(pattern);
+        return;
+      }
+    },
+    { isActive: true }
+  );
+  return /* @__PURE__ */ jsx22(Modal, { children: /* @__PURE__ */ jsxs15(
+    Box16,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.helpDialogBorder,
+      paddingX: 2,
+      paddingY: 1,
+      width: 44,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx22(Text13, { bold: true, color: theme.colors.calendarHeader, underline: true, children: "Make Task Recurring" }),
+        /* @__PURE__ */ jsx22(Box16, { flexDirection: "column", marginTop: 1, children: frequencies.map((freq, idx) => {
+          const isSelected = idx === selectedIndex;
+          return /* @__PURE__ */ jsx22(Box16, { marginY: 0, children: /* @__PURE__ */ jsxs15(
+            Text13,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u279C " : "  ",
+                freq.label
+              ]
+            }
+          ) }, freq.value);
+        }) }),
+        /* @__PURE__ */ jsx22(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx22(Text13, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2191/\u2193 or k/j to navigate \u2022 Enter to confirm \u2022 Esc to cancel" }) })
+      ]
+    }
+  ) });
+};
+
+// src/components/common/RecurringEditDialog.tsx
+import { useState as useState12 } from "react";
+import { Box as Box17, Text as Text14, useInput as useInput10 } from "ink";
+import { jsx as jsx23, jsxs as jsxs16 } from "react/jsx-runtime";
+var RecurringEditDialog = ({
+  taskTitle,
+  actionType,
+  onConfirm
+}) => {
+  const { theme } = useTheme();
+  const [selectedIndex, setSelectedIndex] = useState12(0);
+  const options = [
+    { value: "this", label: getThisOptionLabel(actionType) },
+    { value: "all", label: "All occurrences" },
+    { value: "from-today", label: "All occurrences from today" }
+  ];
+  function getThisOptionLabel(action) {
+    switch (action) {
+      case "edit":
+        return "This task only";
+      case "delete":
+        return "This task only";
+      case "complete":
+        return "This task only";
+      case "state-change":
+        return "This task only";
+      case "add-subtask":
+        return "This task only";
+      default:
+        return "This task only";
+    }
+  }
+  function getActionDescription(action) {
+    switch (action) {
+      case "edit":
+        return "editing";
+      case "delete":
+        return "deleting";
+      case "complete":
+        return "completing";
+      case "state-change":
+        return "changing the state of";
+      case "add-subtask":
+        return "adding a subtask to";
+      default:
+        return "modifying";
+    }
+  }
+  useInput10(
+    (input, key) => {
+      if (key.escape) {
+        logger.log("Cancelling recurring edit dialog");
+        onConfirm("cancel");
+        return;
+      }
+      if (key.upArrow || input === "k") {
+        setSelectedIndex((prev) => prev > 0 ? prev - 1 : options.length - 1);
+        return;
+      }
+      if (key.downArrow || input === "j") {
+        setSelectedIndex((prev) => prev < options.length - 1 ? prev + 1 : 0);
+        return;
+      }
+      if (key.return) {
+        const selectedAction = options[selectedIndex].value;
+        logger.log("Recurring edit action selected", {
+          actionType,
+          selectedAction,
+          taskTitle
+        });
+        onConfirm(selectedAction);
+        return;
+      }
+    },
+    { isActive: true }
+  );
+  return /* @__PURE__ */ jsx23(Modal, { children: /* @__PURE__ */ jsxs16(
+    Box17,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.helpDialogBorder,
+      paddingX: 2,
+      paddingY: 1,
+      width: 54,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx23(Text14, { bold: true, color: theme.colors.calendarHeader, children: "Modify Recurring Task" }),
+        /* @__PURE__ */ jsx23(Box17, { marginTop: 1, marginBottom: 1, children: /* @__PURE__ */ jsxs16(Text14, { color: theme.colors.foreground, children: [
+          "You are ",
+          getActionDescription(actionType),
+          " a recurring task:"
+        ] }) }),
+        /* @__PURE__ */ jsx23(Box17, { marginBottom: 1, children: /* @__PURE__ */ jsxs16(Text14, { color: theme.colors.focusIndicator, bold: true, children: [
+          '"',
+          taskTitle,
+          '"'
+        ] }) }),
+        /* @__PURE__ */ jsx23(Box17, { flexDirection: "column", marginTop: 1, children: options.map((option, idx) => {
+          const isSelected = idx === selectedIndex;
+          return /* @__PURE__ */ jsx23(Box17, { marginY: 0, children: /* @__PURE__ */ jsxs16(
+            Text14,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u279C " : "  ",
+                option.label
+              ]
+            }
+          ) }, option.value);
+        }) }),
+        /* @__PURE__ */ jsx23(Box17, { marginTop: 1, children: /* @__PURE__ */ jsx23(Text14, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2191/\u2193 or k/j to navigate \u2022 Enter to confirm \u2022 Esc to cancel" }) })
+      ]
+    }
+  ) });
+};
+
 // src/components/common/ClearTimelineDialog.tsx
-import { Box as Box15, Text as Text12, useInput as useInput7 } from "ink";
+import { Box as Box18, Text as Text15, useInput as useInput11 } from "ink";
 import { format as format2 } from "date-fns";
-import { jsx as jsx21, jsxs as jsxs14 } from "react/jsx-runtime";
+import { jsx as jsx24, jsxs as jsxs17 } from "react/jsx-runtime";
 var ClearTimelineDialog = () => {
   const { theme } = useTheme();
   const {
@@ -3865,15 +5543,15 @@ var ClearTimelineDialog = () => {
   const handleCancel = () => {
     setShowClearTimelineDialog(false);
   };
-  useInput7((input, key) => {
+  useInput11((input, key) => {
     if (input.toLowerCase() === "y" || key.return) {
       handleConfirm();
     } else if (input.toLowerCase() === "n" || key.escape) {
       handleCancel();
     }
   });
-  return /* @__PURE__ */ jsx21(Modal, { children: /* @__PURE__ */ jsxs14(
-    Box15,
+  return /* @__PURE__ */ jsx24(Modal, { children: /* @__PURE__ */ jsxs17(
+    Box18,
     {
       flexDirection: "column",
       borderStyle: "double",
@@ -3882,34 +5560,34 @@ var ClearTimelineDialog = () => {
       paddingY: 2,
       backgroundColor: theme.colors.modalBackground || theme.colors.background,
       children: [
-        /* @__PURE__ */ jsx21(Box15, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx21(Text12, { bold: true, color: theme.colors.taskStateDelayed, children: "Clear Timeline" }) }),
-        /* @__PURE__ */ jsxs14(Box15, { flexDirection: "column", marginY: 1, children: [
-          /* @__PURE__ */ jsx21(Text12, { color: theme.colors.foreground, children: "You are about to clear the timeline for" }),
-          /* @__PURE__ */ jsx21(Box15, { justifyContent: "center", marginY: 1, children: /* @__PURE__ */ jsx21(Text12, { bold: true, color: theme.colors.calendarHeader, children: formattedDate }) }),
-          eventCount > 0 ? /* @__PURE__ */ jsxs14(Text12, { color: theme.colors.keyboardHint, children: [
+        /* @__PURE__ */ jsx24(Box18, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx24(Text15, { bold: true, color: theme.colors.taskStateDelayed, children: "Clear Timeline" }) }),
+        /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", marginY: 1, children: [
+          /* @__PURE__ */ jsx24(Text15, { color: theme.colors.foreground, children: "You are about to clear the timeline for" }),
+          /* @__PURE__ */ jsx24(Box18, { justifyContent: "center", marginY: 1, children: /* @__PURE__ */ jsx24(Text15, { bold: true, color: theme.colors.calendarHeader, children: formattedDate }) }),
+          eventCount > 0 ? /* @__PURE__ */ jsxs17(Text15, { color: theme.colors.keyboardHint, children: [
             "This will remove ",
             eventCount,
             " event",
             eventCount !== 1 ? "s" : "",
             " from the timeline."
-          ] }) : /* @__PURE__ */ jsx21(Text12, { color: theme.colors.keyboardHint, dimColor: true, children: "The timeline is already empty." })
+          ] }) : /* @__PURE__ */ jsx24(Text15, { color: theme.colors.keyboardHint, dimColor: true, children: "The timeline is already empty." })
         ] }),
-        /* @__PURE__ */ jsxs14(Box15, { marginTop: 2, justifyContent: "center", children: [
-          /* @__PURE__ */ jsx21(Text12, { color: theme.colors.foreground, children: "Are you sure? " }),
-          /* @__PURE__ */ jsx21(Text12, { color: theme.colors.taskStateCompleted, bold: true, children: "[Y]es" }),
-          /* @__PURE__ */ jsx21(Text12, { color: theme.colors.foreground, children: " / " }),
-          /* @__PURE__ */ jsx21(Text12, { color: theme.colors.taskStateDelayed, bold: true, children: "[N]o" })
+        /* @__PURE__ */ jsxs17(Box18, { marginTop: 2, justifyContent: "center", children: [
+          /* @__PURE__ */ jsx24(Text15, { color: theme.colors.foreground, children: "Are you sure? " }),
+          /* @__PURE__ */ jsx24(Text15, { color: theme.colors.taskStateCompleted, bold: true, children: "[Y]es" }),
+          /* @__PURE__ */ jsx24(Text15, { color: theme.colors.foreground, children: " / " }),
+          /* @__PURE__ */ jsx24(Text15, { color: theme.colors.taskStateDelayed, bold: true, children: "[N]o" })
         ] }),
-        /* @__PURE__ */ jsx21(Box15, { marginTop: 2, justifyContent: "center", children: /* @__PURE__ */ jsx21(Text12, { color: theme.colors.keyboardHint, dimColor: true, children: "Press Y to confirm, N or Esc to cancel" }) })
+        /* @__PURE__ */ jsx24(Box18, { marginTop: 2, justifyContent: "center", children: /* @__PURE__ */ jsx24(Text15, { color: theme.colors.keyboardHint, dimColor: true, children: "Press Y to confirm, N or Esc to cancel" }) })
       ]
     }
   ) });
 };
 
 // src/components/common/UpdateDialog.tsx
-import { useState as useState10 } from "react";
-import { Box as Box16, Text as Text13, useInput as useInput8 } from "ink";
-import { jsx as jsx22, jsxs as jsxs15 } from "react/jsx-runtime";
+import { useState as useState13 } from "react";
+import { Box as Box19, Text as Text16, useInput as useInput12 } from "ink";
+import { jsx as jsx25, jsxs as jsxs18 } from "react/jsx-runtime";
 var UpdateDialog = ({
   currentVersion,
   latestVersion,
@@ -3917,12 +5595,12 @@ var UpdateDialog = ({
   onSkipVersion
 }) => {
   const { theme } = useTheme();
-  const [selectedOption, setSelectedOption] = useState10(0);
+  const [selectedOption, setSelectedOption] = useState13(0);
   const options = [
     { label: "Dismiss", action: onDismiss },
     { label: "Skip this version", action: () => onSkipVersion(latestVersion) }
   ];
-  useInput8((input, key) => {
+  useInput12((input, key) => {
     if (key.escape) {
       onDismiss();
       return;
@@ -3940,8 +5618,8 @@ var UpdateDialog = ({
       return;
     }
   });
-  return /* @__PURE__ */ jsx22(Modal, { children: /* @__PURE__ */ jsxs15(
-    Box16,
+  return /* @__PURE__ */ jsx25(Modal, { children: /* @__PURE__ */ jsxs18(
+    Box19,
     {
       flexDirection: "column",
       borderStyle: "double",
@@ -3951,27 +5629,27 @@ var UpdateDialog = ({
       width: 50,
       backgroundColor: theme.colors.modalBackground || theme.colors.background,
       children: [
-        /* @__PURE__ */ jsx22(Text13, { bold: true, color: theme.colors.calendarHeader, children: "Update Available" }),
-        /* @__PURE__ */ jsxs15(Box16, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx22(Text13, { color: theme.colors.foreground, children: "A new version of Epoch is available!" }),
-          /* @__PURE__ */ jsxs15(Box16, { marginTop: 1, children: [
-            /* @__PURE__ */ jsxs15(Text13, { color: theme.colors.foreground, dimColor: true, children: [
+        /* @__PURE__ */ jsx25(Text16, { bold: true, color: theme.colors.calendarHeader, children: "Update Available" }),
+        /* @__PURE__ */ jsxs18(Box19, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx25(Text16, { color: theme.colors.foreground, children: "A new version of Epoch is available!" }),
+          /* @__PURE__ */ jsxs18(Box19, { marginTop: 1, children: [
+            /* @__PURE__ */ jsxs18(Text16, { color: theme.colors.foreground, dimColor: true, children: [
               "Current:",
               " "
             ] }),
-            /* @__PURE__ */ jsx22(Text13, { color: theme.colors.taskDelayed, children: currentVersion }),
-            /* @__PURE__ */ jsx22(Text13, { color: theme.colors.foreground, dimColor: true, children: "  \u2192  " }),
-            /* @__PURE__ */ jsx22(Text13, { color: theme.colors.taskCompleted, bold: true, children: latestVersion })
+            /* @__PURE__ */ jsx25(Text16, { color: theme.colors.taskDelayed, children: currentVersion }),
+            /* @__PURE__ */ jsx25(Text16, { color: theme.colors.foreground, dimColor: true, children: "  \u2192  " }),
+            /* @__PURE__ */ jsx25(Text16, { color: theme.colors.taskCompleted, bold: true, children: latestVersion })
           ] })
         ] }),
-        /* @__PURE__ */ jsxs15(Box16, { marginTop: 1, flexDirection: "column", children: [
-          /* @__PURE__ */ jsx22(Text13, { color: theme.colors.foreground, dimColor: true, children: "To update, run:" }),
-          /* @__PURE__ */ jsx22(Box16, { marginTop: 0, paddingLeft: 1, children: /* @__PURE__ */ jsx22(Text13, { color: theme.colors.timelineEventStarted, children: "npm install -g epoch-tui@latest" }) })
+        /* @__PURE__ */ jsxs18(Box19, { marginTop: 1, flexDirection: "column", children: [
+          /* @__PURE__ */ jsx25(Text16, { color: theme.colors.foreground, dimColor: true, children: "To update, run:" }),
+          /* @__PURE__ */ jsx25(Box19, { marginTop: 0, paddingLeft: 1, children: /* @__PURE__ */ jsx25(Text16, { color: theme.colors.timelineEventStarted, children: "npm install -g epoch-tui@latest" }) })
         ] }),
-        /* @__PURE__ */ jsx22(Box16, { marginTop: 1, flexDirection: "column", children: options.map((option, idx) => {
+        /* @__PURE__ */ jsx25(Box19, { marginTop: 1, flexDirection: "column", children: options.map((option, idx) => {
           const isSelected = idx === selectedOption;
-          return /* @__PURE__ */ jsx22(Box16, { children: /* @__PURE__ */ jsxs15(
-            Text13,
+          return /* @__PURE__ */ jsx25(Box19, { children: /* @__PURE__ */ jsxs18(
+            Text16,
             {
               color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
               bold: isSelected,
@@ -3982,21 +5660,21 @@ var UpdateDialog = ({
             }
           ) }, option.label);
         }) }),
-        /* @__PURE__ */ jsx22(Box16, { marginTop: 1, children: /* @__PURE__ */ jsx22(Text13, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2191/\u2193 to navigate \u2022 Enter to select \u2022 Esc to dismiss" }) })
+        /* @__PURE__ */ jsx25(Box19, { marginTop: 1, children: /* @__PURE__ */ jsx25(Text16, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2191/\u2193 to navigate \u2022 Enter to select \u2022 Esc to dismiss" }) })
       ]
     }
   ) });
 };
 
 // src/components/overview/OverviewScreen.tsx
-import React11, { useMemo as useMemo4 } from "react";
-import { Box as Box17, Text as Text14, useInput as useInput9 } from "ink";
+import React14, { useMemo as useMemo4 } from "react";
+import { Box as Box20, Text as Text17, useInput as useInput13 } from "ink";
 import { startOfMonth as startOfMonth2, endOfMonth as endOfMonth2, eachDayOfInterval as eachDayOfInterval2 } from "date-fns";
-import { jsx as jsx23, jsxs as jsxs16 } from "react/jsx-runtime";
+import { jsx as jsx26, jsxs as jsxs19 } from "react/jsx-runtime";
 var OverviewScreen = () => {
   const { theme } = useTheme();
   const { tasks, overviewMonth, setOverviewMonth, setShowOverview } = useApp();
-  const [scrollOffset, setScrollOffset] = React11.useState(0);
+  const [scrollOffset, setScrollOffset] = React14.useState(0);
   const { height: terminalHeight } = useTerminalSize();
   const visibleRows = useMemo4(() => {
     return Math.max(2, Math.floor((terminalHeight - 9) / 3));
@@ -4032,10 +5710,10 @@ var OverviewScreen = () => {
       setOverviewMonth({ ...overviewMonth, month: newMonth });
     }
   };
-  React11.useEffect(() => {
+  React14.useEffect(() => {
     setScrollOffset(0);
   }, [overviewMonth]);
-  useInput9((input, key) => {
+  useInput13((input, key) => {
     if (key.escape) {
       setShowOverview(false);
       return;
@@ -4071,21 +5749,21 @@ var OverviewScreen = () => {
   );
   const canScrollUp = scrollOffset > 0;
   const canScrollDown = scrollOffset + visibleRows < rows;
-  return /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", padding: 1, width: "100%", height: "100%", children: [
-    /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", marginBottom: 1, children: [
-      /* @__PURE__ */ jsx23(Text14, { bold: true, color: theme.colors.focusIndicator, children: "Overview" }),
-      /* @__PURE__ */ jsx23(Text14, { color: theme.colors.foreground, children: monthName })
+  return /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", padding: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx26(Text17, { bold: true, color: theme.colors.focusIndicator, children: "Overview" }),
+      /* @__PURE__ */ jsx26(Text17, { color: theme.colors.foreground, children: monthName })
     ] }),
-    /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", flexGrow: 1, children: [
-      canScrollUp && /* @__PURE__ */ jsx23(Box17, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx23(Text14, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) }),
+    /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", flexGrow: 1, children: [
+      canScrollUp && /* @__PURE__ */ jsx26(Box20, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx26(Text17, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) }),
       visibleRowData.map((_, index) => {
         const rowIndex = scrollOffset + index;
-        return /* @__PURE__ */ jsx23(Box17, { flexDirection: "row", marginBottom: 1, children: Array.from({ length: columns }).map((_2, colIndex) => {
+        return /* @__PURE__ */ jsx26(Box20, { flexDirection: "row", marginBottom: 1, children: Array.from({ length: columns }).map((_2, colIndex) => {
           const dateIndex = rowIndex * columns + colIndex;
           const date = monthDates[dateIndex];
           if (!date) {
-            return /* @__PURE__ */ jsx23(
-              Box17,
+            return /* @__PURE__ */ jsx26(
+              Box20,
               {
                 flexDirection: "column",
                 flexGrow: 1,
@@ -4105,17 +5783,17 @@ var OverviewScreen = () => {
             }
           };
           traverse(dayTasks, 0);
-          return /* @__PURE__ */ jsxs16(
-            Box17,
+          return /* @__PURE__ */ jsxs19(
+            Box20,
             {
               flexDirection: "column",
               flexGrow: 1,
               flexBasis: 0,
               marginRight: colIndex === columns - 1 ? 0 : 2,
               children: [
-                /* @__PURE__ */ jsx23(Text14, { bold: true, color: theme.colors.calendarSelected, children: formatDate(date, "do MMM") }),
-                /* @__PURE__ */ jsxs16(Box17, { flexDirection: "column", children: [
-                  flatTasksWithDepth.length === 0 ? /* @__PURE__ */ jsx23(Text14, { dimColor: true, color: theme.colors.keyboardHint, children: "No tasks" }) : flatTasksWithDepth.slice(0, 10).map(({ task, depth }) => /* @__PURE__ */ jsx23(
+                /* @__PURE__ */ jsx26(Text17, { bold: true, color: theme.colors.calendarSelected, children: formatDate(date, "do MMM") }),
+                /* @__PURE__ */ jsxs19(Box20, { flexDirection: "column", children: [
+                  flatTasksWithDepth.length === 0 ? /* @__PURE__ */ jsx26(Text17, { dimColor: true, color: theme.colors.keyboardHint, children: "No tasks" }) : flatTasksWithDepth.slice(0, 10).map(({ task, depth }) => /* @__PURE__ */ jsx26(
                     TaskItem,
                     {
                       task,
@@ -4124,7 +5802,7 @@ var OverviewScreen = () => {
                     },
                     task.id
                   )),
-                  flatTasksWithDepth.length > 10 && /* @__PURE__ */ jsxs16(Text14, { dimColor: true, color: theme.colors.keyboardHint, children: [
+                  flatTasksWithDepth.length > 10 && /* @__PURE__ */ jsxs19(Text17, { dimColor: true, color: theme.colors.keyboardHint, children: [
                     "+",
                     flatTasksWithDepth.length - 10,
                     " more..."
@@ -4136,22 +5814,22 @@ var OverviewScreen = () => {
           );
         }) }, rowIndex);
       }),
-      canScrollDown && /* @__PURE__ */ jsx23(Box17, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx23(Text14, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) })
+      canScrollDown && /* @__PURE__ */ jsx26(Box20, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx26(Text17, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) })
     ] }),
-    /* @__PURE__ */ jsx23(Box17, { marginTop: 1, children: /* @__PURE__ */ jsx23(Text14, { color: theme.colors.keyboardHint, dimColor: true, children: "n/p or \u2190/\u2192: month | j/k or \u2193/\u2191: scroll | Esc: close | Shift+;: toggle" }) })
+    /* @__PURE__ */ jsx26(Box20, { marginTop: 1, children: /* @__PURE__ */ jsx26(Text17, { color: theme.colors.keyboardHint, dimColor: true, children: "n/p or \u2190/\u2192: month | j/k or \u2193/\u2191: scroll | Esc: close | Shift+;: toggle" }) })
   ] });
 };
 var TaskItem = ({ task, theme, depth }) => {
   const checkbox = getCheckbox2(task.state);
   const color = getStateColor2(task.state, theme);
-  return /* @__PURE__ */ jsxs16(Box17, { children: [
-    /* @__PURE__ */ jsxs16(Text14, { color, children: [
+  return /* @__PURE__ */ jsxs19(Box20, { children: [
+    /* @__PURE__ */ jsxs19(Text17, { color, children: [
       checkbox,
       " "
     ] }),
-    depth > 0 && /* @__PURE__ */ jsx23(Text14, { children: "  ".repeat(depth) }),
-    /* @__PURE__ */ jsx23(
-      Text14,
+    depth > 0 && /* @__PURE__ */ jsx26(Text17, { children: "  ".repeat(depth) }),
+    /* @__PURE__ */ jsx26(
+      Text17,
       {
         color,
         strikethrough: task.state === "completed",
@@ -4184,7 +5862,7 @@ function getStateColor2(state, theme) {
 }
 
 // src/App.tsx
-import { jsx as jsx24, jsxs as jsxs17 } from "react/jsx-runtime";
+import { jsx as jsx27, jsxs as jsxs20 } from "react/jsx-runtime";
 var AppContent = () => {
   const {
     showHelp,
@@ -4193,16 +5871,28 @@ var AppContent = () => {
     activePane,
     showThemeDialog,
     showClearTimelineDialog,
+    showSettingsDialog,
+    showRecurringTaskDialog,
+    showRecurringEditDialog,
     showUpdateDialog,
     setShowUpdateDialog,
     updateInfo,
-    skipVersion
+    skipVersion,
+    recurringTaskId,
+    setRecurringTaskId,
+    setShowRecurringTaskDialog,
+    recurringEditConfig,
+    setRecurringEditConfig,
+    setShowRecurringEditDialog,
+    tasks,
+    setTasks,
+    pushUndoableAction
   } = useApp();
   const { theme } = useTheme();
   useKeyboardNav();
   const { width, height } = useTerminalSize();
   if (showUpdateDialog && updateInfo) {
-    return /* @__PURE__ */ jsx24(
+    return /* @__PURE__ */ jsx27(
       UpdateDialog,
       {
         currentVersion: updateInfo.currentVersion,
@@ -4213,26 +5903,78 @@ var AppContent = () => {
     );
   }
   if (showThemeDialog) {
-    return /* @__PURE__ */ jsx24(ThemeDialog, {});
+    return /* @__PURE__ */ jsx27(ThemeDialog, {});
   }
   if (showHelp) {
-    return /* @__PURE__ */ jsx24(HelpDialog, {});
+    return /* @__PURE__ */ jsx27(HelpDialog, {});
   }
   if (showClearTimelineDialog) {
-    return /* @__PURE__ */ jsx24(ClearTimelineDialog, {});
+    return /* @__PURE__ */ jsx27(ClearTimelineDialog, {});
+  }
+  if (showSettingsDialog) {
+    return /* @__PURE__ */ jsx27(SettingsDialog, {});
+  }
+  if (showRecurringTaskDialog && recurringTaskId) {
+    const handleConfirm = (pattern) => {
+      try {
+        pushUndoableAction("TASK_UPDATE");
+        const updated = taskService.updateTask(tasks, recurringTaskId, {
+          recurrence: pattern
+        });
+        setTasks(updated);
+        setShowRecurringTaskDialog(false);
+        setRecurringTaskId(null);
+      } catch (err) {
+        console.error("Error setting task recurrence:", err);
+      }
+    };
+    const handleCancel = () => {
+      setShowRecurringTaskDialog(false);
+      setRecurringTaskId(null);
+    };
+    return /* @__PURE__ */ jsx27(RecurringTaskDialog, { onConfirm: handleConfirm, onCancel: handleCancel });
+  }
+  if (showRecurringEditDialog && recurringEditConfig) {
+    const handleConfirm = (action) => {
+      logger.log("[App] RecurringEditDialog handleConfirm called", { action, actionType: recurringEditConfig.actionType });
+      if (action === "cancel") {
+        logger.log("[App] User cancelled, closing dialog");
+        setShowRecurringEditDialog(false);
+        setRecurringEditConfig(null);
+        return;
+      }
+      if (action === "this" || action === "all" || action === "from-today") {
+        logger.log("[App] Calling onConfirm callback from TasksPane", { action });
+        recurringEditConfig.onConfirm(action);
+      }
+      logger.log("[App] Scheduling dialog close");
+      setTimeout(() => {
+        logger.log("[App] Closing dialog now");
+        setShowRecurringEditDialog(false);
+        setRecurringEditConfig(null);
+      }, 0);
+    };
+    return /* @__PURE__ */ jsx27(
+      RecurringEditDialog,
+      {
+        taskTitle: recurringEditConfig.taskTitle,
+        actionType: recurringEditConfig.actionType,
+        onConfirm: handleConfirm
+      }
+    );
   }
-  return /* @__PURE__ */ jsx24(FullscreenBackground, { backgroundColor: theme.colors.background || "black", children: /* @__PURE__ */ jsxs17(Box18, { flexDirection: "column", width, height, padding: 1, backgroundColor: theme.colors.background, children: [
-    showOverview ? /* @__PURE__ */ jsx24(OverviewScreen, {}) : /* @__PURE__ */ jsx24(
+  return /* @__PURE__ */ jsx27(FullscreenBackground, { backgroundColor: theme.colors.background || "black", children: /* @__PURE__ */ jsxs20(Box21, { flexDirection: "column", width, height, padding: 1, backgroundColor: theme.colors.background, children: [
+    showOverview ? /* @__PURE__ */ jsx27(OverviewScreen, {}) : /* @__PURE__ */ jsx27(
       ThreeColumnLayout,
       {
-        leftPane: /* @__PURE__ */ jsx24(CalendarPane, {}),
-        centerPane: /* @__PURE__ */ jsx24(TasksPane, {}),
-        rightPane: /* @__PURE__ */ jsx24(TimelinePane, {}),
+        leftPane: /* @__PURE__ */ jsx27(CalendarPane, {}),
+        centerPane: /* @__PURE__ */ jsx27(TasksPane, {}),
+        rightPane: /* @__PURE__ */ jsx27(TimelinePane, {}),
         activePane,
         height: height - 2
       }
     ),
-    exitConfirmation && /* @__PURE__ */ jsx24(Box18, { width: "100%", justifyContent: "center", paddingY: 1, children: /* @__PURE__ */ jsxs17(Text15, { backgroundColor: "red", color: "white", bold: true, children: [
+    exitConfirmation && /* @__PURE__ */ jsx27(Box21, { width: "100%", justifyContent: "center", paddingY: 1, children: /* @__PURE__ */ jsxs20(Text18, { backgroundColor: "red", color: "white", bold: true, children: [
       " ",
       "Press Ctrl+C again to exit Epoch",
       " "
@@ -4240,12 +5982,12 @@ var AppContent = () => {
   ] }) });
 };
 var App = () => {
-  return /* @__PURE__ */ jsx24(StorageProvider, { children: /* @__PURE__ */ jsx24(ThemeProvider, { initialTheme: "dark", children: /* @__PURE__ */ jsx24(UndoProvider, { children: /* @__PURE__ */ jsx24(AppProvider, { children: /* @__PURE__ */ jsx24(AppContent, {}) }) }) }) });
+  return /* @__PURE__ */ jsx27(StorageProvider, { children: /* @__PURE__ */ jsx27(ThemeProvider, { initialTheme: "dark", children: /* @__PURE__ */ jsx27(UndoProvider, { children: /* @__PURE__ */ jsx27(AppProvider, { children: /* @__PURE__ */ jsx27(AppContent, {}) }) }) }) });
 };
 var App_default = App;
 
 // src/index.tsx
-import { jsx as jsx25 } from "react/jsx-runtime";
+import { jsx as jsx28 } from "react/jsx-runtime";
 console.clear();
-var app = render(/* @__PURE__ */ jsx25(App_default, {}), { exitOnCtrlC: false });
+var app = render(/* @__PURE__ */ jsx28(App_default, {}), { exitOnCtrlC: false });
 global.__inkApp = app;