epoch-tui 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,8 +1,3808 @@
 #!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
+
+// src/index.tsx
 import { render } from "ink";
-import App from "./App";
+
+// src/App.tsx
+import { Box as Box16, Text as Text12 } from "ink";
+
+// src/contexts/ThemeContext.tsx
+import { createContext as createContext2, useContext as useContext2, useState as useState2, useEffect as useEffect2 } from "react";
+
+// src/themes/dark.ts
+var darkTheme = {
+  name: "dark",
+  colors: {
+    background: "#1a1a1a",
+    foreground: "#e5e5e5",
+    border: "#404040",
+    calendarBorder: "#404040",
+    calendarHeader: "#f59e0b",
+    // Amber
+    calendarToday: "#f59e0b",
+    // Amber
+    calendarSelected: "#fbbf24",
+    // Amber light
+    calendarDayWithTasks: "#d97706",
+    // Amber dark
+    calendarDayOtherMonth: "#525252",
+    taskBorder: "#404040",
+    taskHeader: "#f59e0b",
+    // Amber
+    taskCheckboxEmpty: "#525252",
+    taskCheckboxFilled: "#f59e0b",
+    // Amber
+    taskStateTodo: "#e5e5e5",
+    taskStateCompleted: "#737373",
+    taskStateDelegated: "#a3a3a3",
+    taskStateDelayed: "#fbbf24",
+    // Amber light for attention
+    taskIndent: "#525252",
+    timelineBorder: "#404040",
+    timelineHeader: "#f59e0b",
+    // Amber
+    timelineTimestamp: "#737373",
+    timelineEventCreated: "#e5e5e5",
+    timelineEventStarted: "#fbbf24",
+    // Amber light
+    timelineEventCompleted: "#a3a3a3",
+    timelineEventDelegated: "#8a8a8a",
+    timelineEventDelayed: "#f59e0b",
+    // Amber
+    separator: "#404040",
+    keyboardHint: "#737373",
+    helpDialogBorder: "#f59e0b",
+    // Amber
+    focusIndicator: "#f59e0b",
+    // Amber
+    modalOverlay: "#0a0a0a",
+    modalBackground: "#1a1a1a"
+  }
+};
+
+// src/themes/light.ts
+var lightTheme = {
+  name: "light",
+  colors: {
+    // Hex colors work with Ink's Text backgroundColor (via chalk)
+    background: "#f5f5f5",
+    foreground: "#1a1a1a",
+    border: "#888888",
+    calendarBorder: "#888888",
+    calendarHeader: "#0066cc",
+    calendarToday: "#00aa77",
+    calendarSelected: "#9933cc",
+    calendarDayWithTasks: "#cc6600",
+    calendarDayOtherMonth: "#666666",
+    // Darker
+    taskBorder: "#888888",
+    taskHeader: "#0066cc",
+    taskCheckboxEmpty: "#666666",
+    // Darker
+    taskCheckboxFilled: "#00aa77",
+    taskStateTodo: "#1a1a1a",
+    taskStateCompleted: "#00aa77",
+    taskStateDelegated: "#cc6600",
+    taskStateDelayed: "#cc3333",
+    taskIndent: "#888888",
+    timelineBorder: "#888888",
+    timelineHeader: "#0066cc",
+    timelineTimestamp: "#444444",
+    // Darker
+    timelineEventCreated: "#0066cc",
+    timelineEventStarted: "#cc6600",
+    timelineEventCompleted: "#00aa77",
+    timelineEventDelegated: "#9933cc",
+    timelineEventDelayed: "#cc3333",
+    separator: "#888888",
+    keyboardHint: "#444444",
+    // Darker
+    helpDialogBorder: "#0066cc",
+    focusIndicator: "#9933cc",
+    modalOverlay: "#e0e0e0",
+    modalBackground: "#f5f5f5"
+  }
+};
+
+// src/themes/terminal.ts
+var terminalTheme = {
+  name: "terminal",
+  colors: {
+    // defaults rely on terminal settings
+    border: "gray",
+    calendarBorder: "gray",
+    calendarHeader: "blue",
+    calendarToday: "green",
+    calendarSelected: "magenta",
+    calendarDayWithTasks: "yellow",
+    calendarDayOtherMonth: "gray",
+    taskBorder: "gray",
+    taskHeader: "blue",
+    taskCheckboxEmpty: "gray",
+    taskCheckboxFilled: "green",
+    taskStateTodo: void 0,
+    // default
+    taskStateCompleted: "green",
+    taskStateDelegated: "magenta",
+    taskStateDelayed: "red",
+    taskIndent: "gray",
+    timelineBorder: "gray",
+    timelineHeader: "blue",
+    timelineTimestamp: "gray",
+    timelineEventCreated: "cyan",
+    timelineEventStarted: "yellow",
+    timelineEventCompleted: "green",
+    timelineEventDelegated: "magenta",
+    timelineEventDelayed: "red",
+    separator: "gray",
+    keyboardHint: "gray",
+    helpDialogBorder: "blue",
+    focusIndicator: "cyan",
+    // Modal colors follow terminal defaults
+    modalOverlay: void 0,
+    modalBackground: void 0
+  }
+};
+
+// src/themes/claude.ts
+var claudeTheme = {
+  name: "claude",
+  colors: {
+    // Warm cream background with white text
+    background: "#F4F3EE",
+    foreground: "#1a1614",
+    border: "#B1ADA1",
+    // Calendar - Rust accents
+    calendarBorder: "#B1ADA1",
+    calendarHeader: "#C15F3C",
+    calendarToday: "#C15F3C",
+    calendarSelected: "#C15F3C",
+    calendarDayWithTasks: "#C15F3C",
+    calendarDayOtherMonth: "#736F66",
+    // Darker for readability
+    // Tasks - Warm palette
+    taskBorder: "#B1ADA1",
+    taskHeader: "#C15F3C",
+    taskCheckboxEmpty: "#736F66",
+    // Darker for readability
+    taskCheckboxFilled: "#98C379",
+    taskStateTodo: "#1a1614",
+    taskStateCompleted: "#98C379",
+    taskStateDelegated: "#736F66",
+    // Darker for readability
+    taskStateDelayed: "#E06C75",
+    taskIndent: "#B1ADA1",
+    // Timeline - Rust theme
+    timelineBorder: "#B1ADA1",
+    timelineHeader: "#C15F3C",
+    timelineTimestamp: "#736F66",
+    // Darker for readability
+    timelineEventCreated: "#61AFEF",
+    timelineEventStarted: "#C15F3C",
+    timelineEventCompleted: "#98C379",
+    timelineEventDelegated: "#736F66",
+    timelineEventDelayed: "#E06C75",
+    // UI elements
+    separator: "#B1ADA1",
+    keyboardHint: "#736F66",
+    // Darker for readability
+    helpDialogBorder: "#C15F3C",
+    focusIndicator: "#C15F3C",
+    // Modal - Light overlay
+    modalOverlay: "#F4F3EE",
+    modalBackground: "#FFFFFF"
+  }
+};
+
+// src/themes/githubDark.ts
+var githubDarkTheme = {
+  name: "github-dark",
+  colors: {
+    background: "#0d1117",
+    foreground: "#c9d1d9",
+    border: "#30363d",
+    calendarBorder: "#30363d",
+    calendarHeader: "#58a6ff",
+    calendarToday: "#1f6feb",
+    calendarSelected: "#1f6feb",
+    calendarDayWithTasks: "#238636",
+    calendarDayOtherMonth: "#484f58",
+    taskBorder: "#30363d",
+    taskHeader: "#58a6ff",
+    taskCheckboxEmpty: "#484f58",
+    taskCheckboxFilled: "#3fb950",
+    taskStateTodo: "#c9d1d9",
+    taskStateCompleted: "#8b949e",
+    taskStateDelegated: "#a371f7",
+    taskStateDelayed: "#d29922",
+    taskIndent: "#484f58",
+    timelineBorder: "#30363d",
+    timelineHeader: "#58a6ff",
+    timelineTimestamp: "#8b949e",
+    timelineEventCreated: "#58a6ff",
+    timelineEventStarted: "#d29922",
+    timelineEventCompleted: "#3fb950",
+    timelineEventDelegated: "#a371f7",
+    timelineEventDelayed: "#f85149",
+    separator: "#30363d",
+    keyboardHint: "#8b949e",
+    helpDialogBorder: "#58a6ff",
+    focusIndicator: "#58a6ff",
+    modalOverlay: "#0d1117",
+    modalBackground: "#161b22"
+  }
+};
+
+// src/themes/githubLight.ts
+var githubLightTheme = {
+  name: "github-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#24292f",
+    border: "#d0d7de",
+    calendarBorder: "#d0d7de",
+    calendarHeader: "#0969da",
+    // Blue
+    calendarToday: "#0969da",
+    calendarSelected: "#0969da",
+    calendarDayWithTasks: "#1a7f37",
+    // Green
+    calendarDayOtherMonth: "#8c959f",
+    taskBorder: "#d0d7de",
+    taskHeader: "#0969da",
+    taskCheckboxEmpty: "#8c959f",
+    taskCheckboxFilled: "#1a7f37",
+    taskStateTodo: "#24292f",
+    taskStateCompleted: "#8c959f",
+    taskStateDelegated: "#8250df",
+    // Purple
+    taskStateDelayed: "#bf8700",
+    // Yellow/Orange
+    taskIndent: "#d0d7de",
+    timelineBorder: "#d0d7de",
+    timelineHeader: "#0969da",
+    timelineTimestamp: "#8c959f",
+    timelineEventCreated: "#0969da",
+    timelineEventStarted: "#bf8700",
+    timelineEventCompleted: "#1a7f37",
+    timelineEventDelegated: "#8250df",
+    timelineEventDelayed: "#cf222e",
+    // Red
+    separator: "#d0d7de",
+    keyboardHint: "#656d76",
+    helpDialogBorder: "#0969da",
+    focusIndicator: "#0969da",
+    modalOverlay: "#00000033",
+    modalBackground: "#f6f8fa"
+  }
+};
+
+// src/themes/catppuccin.ts
+var catppuccinTheme = {
+  name: "catppuccin",
+  colors: {
+    background: "#1e1e2e",
+    foreground: "#cdd6f4",
+    border: "#45475a",
+    calendarBorder: "#45475a",
+    calendarHeader: "#89b4fa",
+    // Blue
+    calendarToday: "#cba6f7",
+    // Mauve
+    calendarSelected: "#cba6f7",
+    calendarDayWithTasks: "#a6e3a1",
+    // Green
+    calendarDayOtherMonth: "#585b70",
+    // Surface 2
+    taskBorder: "#45475a",
+    taskHeader: "#89b4fa",
+    taskCheckboxEmpty: "#585b70",
+    taskCheckboxFilled: "#a6e3a1",
+    taskStateTodo: "#cdd6f4",
+    taskStateCompleted: "#a6adc8",
+    // Subtext 0
+    taskStateDelegated: "#f5c2e7",
+    // Pink
+    taskStateDelayed: "#fab387",
+    // Peach
+    taskIndent: "#585b70",
+    timelineBorder: "#45475a",
+    timelineHeader: "#89b4fa",
+    timelineTimestamp: "#a6adc8",
+    timelineEventCreated: "#89b4fa",
+    timelineEventStarted: "#fab387",
+    timelineEventCompleted: "#a6e3a1",
+    timelineEventDelegated: "#f5c2e7",
+    timelineEventDelayed: "#f38ba8",
+    // Red
+    separator: "#45475a",
+    keyboardHint: "#a6adc8",
+    helpDialogBorder: "#cba6f7",
+    focusIndicator: "#cba6f7",
+    modalOverlay: "#181825",
+    // Mantle
+    modalBackground: "#1e1e2e"
+  }
+};
+
+// src/themes/catppuccinLatte.ts
+var catppuccinLatteTheme = {
+  name: "catppuccin-latte",
+  colors: {
+    background: "#eff1f5",
+    // Base
+    foreground: "#4c4f69",
+    // Text
+    border: "#ccd0da",
+    // Surface 0
+    calendarBorder: "#ccd0da",
+    calendarHeader: "#1e66f5",
+    // Blue
+    calendarToday: "#8839ef",
+    // Mauve
+    calendarSelected: "#8839ef",
+    calendarDayWithTasks: "#40a02b",
+    // Green
+    calendarDayOtherMonth: "#9ca0b0",
+    // Overlay 0
+    taskBorder: "#ccd0da",
+    taskHeader: "#1e66f5",
+    taskCheckboxEmpty: "#9ca0b0",
+    taskCheckboxFilled: "#40a02b",
+    taskStateTodo: "#4c4f69",
+    taskStateCompleted: "#6c6f85",
+    // Subtext 0
+    taskStateDelegated: "#ea76cb",
+    // Pink
+    taskStateDelayed: "#fe640b",
+    // Peach
+    taskIndent: "#bcc0cc",
+    // Surface 1
+    timelineBorder: "#ccd0da",
+    timelineHeader: "#1e66f5",
+    timelineTimestamp: "#6c6f85",
+    timelineEventCreated: "#1e66f5",
+    timelineEventStarted: "#fe640b",
+    timelineEventCompleted: "#40a02b",
+    timelineEventDelegated: "#ea76cb",
+    timelineEventDelayed: "#d20f39",
+    // Red
+    separator: "#ccd0da",
+    keyboardHint: "#6c6f85",
+    helpDialogBorder: "#8839ef",
+    focusIndicator: "#8839ef",
+    modalOverlay: "#e6e9ef",
+    // Mantle
+    modalBackground: "#eff1f5"
+  }
+};
+
+// src/themes/ubuntu.ts
+var ubuntuTheme = {
+  name: "ubuntu",
+  colors: {
+    background: "#2c001e",
+    // Aubergine
+    foreground: "#f6f5f4",
+    border: "#5c5c5c",
+    // Warm Grey
+    calendarBorder: "#5c5c5c",
+    calendarHeader: "#E95420",
+    // Orange
+    calendarToday: "#E95420",
+    calendarSelected: "#E95420",
+    calendarDayWithTasks: "#77216F",
+    // Aubergine light / Purple
+    calendarDayOtherMonth: "#AEA79F",
+    taskBorder: "#5c5c5c",
+    taskHeader: "#E95420",
+    taskCheckboxEmpty: "#AEA79F",
+    taskCheckboxFilled: "#0E8420",
+    // Green
+    taskStateTodo: "#f6f5f4",
+    taskStateCompleted: "#AEA79F",
+    taskStateDelegated: "#77216F",
+    taskStateDelayed: "#C7162B",
+    // Red
+    taskIndent: "#5c5c5c",
+    timelineBorder: "#5c5c5c",
+    timelineHeader: "#E95420",
+    timelineTimestamp: "#AEA79F",
+    timelineEventCreated: "#E95420",
+    timelineEventStarted: "#F99B11",
+    timelineEventCompleted: "#0E8420",
+    timelineEventDelegated: "#77216F",
+    timelineEventDelayed: "#C7162B",
+    separator: "#5c5c5c",
+    keyboardHint: "#AEA79F",
+    helpDialogBorder: "#E95420",
+    focusIndicator: "#E95420",
+    modalOverlay: "#1a0012",
+    modalBackground: "#300a24"
+  }
+};
+
+// src/themes/ubuntuLight.ts
+var ubuntuLightTheme = {
+  name: "ubuntu-light",
+  colors: {
+    background: "#fafafa",
+    foreground: "#3d3d3d",
+    border: "#cdcdcd",
+    calendarBorder: "#cdcdcd",
+    calendarHeader: "#e95420",
+    // Ubuntu Orange
+    calendarToday: "#e95420",
+    calendarSelected: "#e95420",
+    calendarDayWithTasks: "#77216f",
+    // Ubuntu Aubergine
+    calendarDayOtherMonth: "#929292",
+    taskBorder: "#cdcdcd",
+    taskHeader: "#e95420",
+    taskCheckboxEmpty: "#929292",
+    taskCheckboxFilled: "#0e8420",
+    // Ubuntu Green
+    taskStateTodo: "#3d3d3d",
+    taskStateCompleted: "#929292",
+    taskStateDelegated: "#77216f",
+    taskStateDelayed: "#c7162b",
+    // Ubuntu Red
+    taskIndent: "#cdcdcd",
+    timelineBorder: "#cdcdcd",
+    timelineHeader: "#e95420",
+    timelineTimestamp: "#929292",
+    timelineEventCreated: "#e95420",
+    timelineEventStarted: "#f99b11",
+    // Light Orange
+    timelineEventCompleted: "#0e8420",
+    timelineEventDelegated: "#77216f",
+    timelineEventDelayed: "#c7162b",
+    separator: "#cdcdcd",
+    keyboardHint: "#929292",
+    helpDialogBorder: "#e95420",
+    focusIndicator: "#e95420",
+    modalOverlay: "#e8e8e8",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/atomOneDark.ts
+var atomOneDarkTheme = {
+  name: "atom",
+  colors: {
+    background: "#282c34",
+    foreground: "#abb2bf",
+    border: "#4b5263",
+    calendarBorder: "#4b5263",
+    calendarHeader: "#61afef",
+    // Blue
+    calendarToday: "#c678dd",
+    // Purple
+    calendarSelected: "#c678dd",
+    calendarDayWithTasks: "#98c379",
+    // Green
+    calendarDayOtherMonth: "#5c6370",
+    taskBorder: "#4b5263",
+    taskHeader: "#61afef",
+    taskCheckboxEmpty: "#5c6370",
+    taskCheckboxFilled: "#98c379",
+    taskStateTodo: "#abb2bf",
+    taskStateCompleted: "#5c6370",
+    taskStateDelegated: "#c678dd",
+    taskStateDelayed: "#e5c07b",
+    // Yellow
+    taskIndent: "#5c6370",
+    timelineBorder: "#4b5263",
+    timelineHeader: "#61afef",
+    timelineTimestamp: "#5c6370",
+    timelineEventCreated: "#61afef",
+    timelineEventStarted: "#e5c07b",
+    timelineEventCompleted: "#98c379",
+    timelineEventDelegated: "#c678dd",
+    timelineEventDelayed: "#e06c75",
+    // Red
+    separator: "#4b5263",
+    keyboardHint: "#5c6370",
+    helpDialogBorder: "#61afef",
+    focusIndicator: "#56b6c2",
+    // Cyan
+    modalOverlay: "#21252b",
+    modalBackground: "#282c34"
+  }
+};
+
+// src/themes/atomOneLight.ts
+var atomOneLightTheme = {
+  name: "atom-light",
+  colors: {
+    background: "#fafafa",
+    foreground: "#383a42",
+    border: "#a0a1a7",
+    calendarBorder: "#a0a1a7",
+    calendarHeader: "#4078f2",
+    // Blue
+    calendarToday: "#a626a4",
+    // Purple
+    calendarSelected: "#a626a4",
+    calendarDayWithTasks: "#50a14f",
+    // Green
+    calendarDayOtherMonth: "#a0a1a7",
+    taskBorder: "#a0a1a7",
+    taskHeader: "#4078f2",
+    taskCheckboxEmpty: "#a0a1a7",
+    taskCheckboxFilled: "#50a14f",
+    taskStateTodo: "#383a42",
+    taskStateCompleted: "#a0a1a7",
+    taskStateDelegated: "#a626a4",
+    taskStateDelayed: "#c18401",
+    // Yellow/Orange
+    taskIndent: "#d0d0d0",
+    timelineBorder: "#a0a1a7",
+    timelineHeader: "#4078f2",
+    timelineTimestamp: "#a0a1a7",
+    timelineEventCreated: "#4078f2",
+    timelineEventStarted: "#c18401",
+    timelineEventCompleted: "#50a14f",
+    timelineEventDelegated: "#a626a4",
+    timelineEventDelayed: "#e45649",
+    // Red
+    separator: "#a0a1a7",
+    keyboardHint: "#a0a1a7",
+    helpDialogBorder: "#4078f2",
+    focusIndicator: "#0184bc",
+    // Cyan
+    modalOverlay: "#e8e8e8",
+    modalBackground: "#fafafa"
+  }
+};
+
+// src/themes/intellij.ts
+var intellijTheme = {
+  name: "intellij",
+  colors: {
+    background: "#2b2b2b",
+    foreground: "#a9b7c6",
+    border: "#323232",
+    calendarBorder: "#323232",
+    calendarHeader: "#cc7832",
+    // Orange (Keyword)
+    calendarToday: "#3592c4",
+    // Blue (Accent)
+    calendarSelected: "#3592c4",
+    calendarDayWithTasks: "#6a8759",
+    // Green (String)
+    calendarDayOtherMonth: "#606366",
+    taskBorder: "#323232",
+    taskHeader: "#cc7832",
+    taskCheckboxEmpty: "#606366",
+    taskCheckboxFilled: "#6a8759",
+    taskStateTodo: "#a9b7c6",
+    taskStateCompleted: "#606366",
+    taskStateDelegated: "#9876aa",
+    // Purple
+    taskStateDelayed: "#ffc66d",
+    // Yellow
+    taskIndent: "#606366",
+    timelineBorder: "#323232",
+    timelineHeader: "#cc7832",
+    timelineTimestamp: "#808080",
+    timelineEventCreated: "#6897bb",
+    // Light Blue
+    timelineEventStarted: "#cc7832",
+    timelineEventCompleted: "#6a8759",
+    timelineEventDelegated: "#9876aa",
+    timelineEventDelayed: "#cc7832",
+    separator: "#323232",
+    keyboardHint: "#808080",
+    helpDialogBorder: "#3592c4",
+    focusIndicator: "#3592c4",
+    modalOverlay: "#1e1e1e",
+    modalBackground: "#3c3f41"
+  }
+};
+
+// src/themes/intellijLight.ts
+var intellijLightTheme = {
+  name: "intellij-light",
+  colors: {
+    background: "#f7f7f7",
+    foreground: "#000000",
+    border: "#c4c4c4",
+    calendarBorder: "#c4c4c4",
+    calendarHeader: "#0033b3",
+    // Keyword Blue
+    calendarToday: "#0033b3",
+    calendarSelected: "#0033b3",
+    calendarDayWithTasks: "#067d17",
+    // String Green
+    calendarDayOtherMonth: "#8c8c8c",
+    taskBorder: "#c4c4c4",
+    taskHeader: "#0033b3",
+    taskCheckboxEmpty: "#8c8c8c",
+    taskCheckboxFilled: "#067d17",
+    taskStateTodo: "#000000",
+    taskStateCompleted: "#8c8c8c",
+    taskStateDelegated: "#871094",
+    // Purple
+    taskStateDelayed: "#9e880d",
+    // Yellow
+    taskIndent: "#d4d4d4",
+    timelineBorder: "#c4c4c4",
+    timelineHeader: "#0033b3",
+    timelineTimestamp: "#8c8c8c",
+    timelineEventCreated: "#0033b3",
+    timelineEventStarted: "#9e880d",
+    timelineEventCompleted: "#067d17",
+    timelineEventDelegated: "#871094",
+    timelineEventDelayed: "#c00000",
+    // Red
+    separator: "#c4c4c4",
+    keyboardHint: "#8c8c8c",
+    helpDialogBorder: "#0033b3",
+    focusIndicator: "#0033b3",
+    modalOverlay: "#e8e8e8",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/nord.ts
+var nordTheme = {
+  name: "nord",
+  colors: {
+    background: "#2e3440",
+    foreground: "#d8dee9",
+    border: "#3b4252",
+    calendarBorder: "#3b4252",
+    calendarHeader: "#88c0d0",
+    // Frost Blue
+    calendarToday: "#81a1c1",
+    // Frost Blue darker
+    calendarSelected: "#81a1c1",
+    calendarDayWithTasks: "#a3be8c",
+    // Green
+    calendarDayOtherMonth: "#4c566a",
+    taskBorder: "#3b4252",
+    taskHeader: "#88c0d0",
+    taskCheckboxEmpty: "#4c566a",
+    taskCheckboxFilled: "#a3be8c",
+    taskStateTodo: "#d8dee9",
+    taskStateCompleted: "#4c566a",
+    taskStateDelegated: "#b48ead",
+    // Purple
+    taskStateDelayed: "#d08770",
+    // Orange
+    taskIndent: "#4c566a",
+    timelineBorder: "#3b4252",
+    timelineHeader: "#88c0d0",
+    timelineTimestamp: "#4c566a",
+    timelineEventCreated: "#5e81ac",
+    // Darkest Blue
+    timelineEventStarted: "#ebcb8b",
+    // Yellow
+    timelineEventCompleted: "#a3be8c",
+    timelineEventDelegated: "#b48ead",
+    timelineEventDelayed: "#bf616a",
+    // Red
+    separator: "#3b4252",
+    keyboardHint: "#4c566a",
+    helpDialogBorder: "#88c0d0",
+    focusIndicator: "#88c0d0",
+    modalOverlay: "#242933",
+    modalBackground: "#3b4252"
+  }
+};
+
+// src/themes/nordLight.ts
+var nordLightTheme = {
+  name: "nord-light",
+  colors: {
+    background: "#eceff4",
+    // Nord6 (Snow Storm)
+    foreground: "#2e3440",
+    // Nord0 (Polar Night)
+    border: "#d8dee9",
+    // Nord4
+    calendarBorder: "#d8dee9",
+    calendarHeader: "#5e81ac",
+    // Nord10 (Frost - darkest blue)
+    calendarToday: "#5e81ac",
+    calendarSelected: "#5e81ac",
+    calendarDayWithTasks: "#a3be8c",
+    // Nord14 (Aurora - green)
+    calendarDayOtherMonth: "#4c566a",
+    // Nord3
+    taskBorder: "#d8dee9",
+    taskHeader: "#5e81ac",
+    taskCheckboxEmpty: "#4c566a",
+    taskCheckboxFilled: "#a3be8c",
+    taskStateTodo: "#2e3440",
+    taskStateCompleted: "#4c566a",
+    taskStateDelegated: "#b48ead",
+    // Nord15 (Aurora - purple)
+    taskStateDelayed: "#d08770",
+    // Nord12 (Aurora - orange)
+    taskIndent: "#d8dee9",
+    timelineBorder: "#d8dee9",
+    timelineHeader: "#5e81ac",
+    timelineTimestamp: "#4c566a",
+    timelineEventCreated: "#81a1c1",
+    // Nord9 (Frost)
+    timelineEventStarted: "#ebcb8b",
+    // Nord13 (Aurora - yellow)
+    timelineEventCompleted: "#a3be8c",
+    timelineEventDelegated: "#b48ead",
+    timelineEventDelayed: "#bf616a",
+    // Nord11 (Aurora - red)
+    separator: "#d8dee9",
+    keyboardHint: "#4c566a",
+    helpDialogBorder: "#5e81ac",
+    focusIndicator: "#5e81ac",
+    modalOverlay: "#e5e9f0",
+    // Nord5
+    modalBackground: "#eceff4"
+  }
+};
+
+// src/themes/postman.ts
+var postmanTheme = {
+  name: "postman",
+  colors: {
+    background: "#212121",
+    foreground: "#ededed",
+    border: "#333333",
+    calendarBorder: "#333333",
+    calendarHeader: "#EF5B25",
+    // Postman Orange
+    calendarToday: "#EF5B25",
+    calendarSelected: "#EF5B25",
+    calendarDayWithTasks: "#00B8D9",
+    // Accent Blueish
+    calendarDayOtherMonth: "#666666",
+    taskBorder: "#333333",
+    taskHeader: "#EF5B25",
+    taskCheckboxEmpty: "#666666",
+    taskCheckboxFilled: "#00B8D9",
+    taskStateTodo: "#ededed",
+    taskStateCompleted: "#666666",
+    taskStateDelegated: "#FF9900",
+    taskStateDelayed: "#FF3333",
+    taskIndent: "#333333",
+    timelineBorder: "#333333",
+    timelineHeader: "#EF5B25",
+    timelineTimestamp: "#666666",
+    timelineEventCreated: "#EF5B25",
+    timelineEventStarted: "#FF9900",
+    timelineEventCompleted: "#00B8D9",
+    timelineEventDelegated: "#6554C0",
+    // Purple
+    timelineEventDelayed: "#FF3333",
+    separator: "#333333",
+    keyboardHint: "#666666",
+    helpDialogBorder: "#EF5B25",
+    focusIndicator: "#EF5B25",
+    modalOverlay: "#121212",
+    modalBackground: "#212121"
+  }
+};
+
+// src/themes/postmanLight.ts
+var postmanLightTheme = {
+  name: "postman-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#212121",
+    border: "#e0e0e0",
+    calendarBorder: "#e0e0e0",
+    calendarHeader: "#ff6c37",
+    // Postman Orange
+    calendarToday: "#ff6c37",
+    calendarSelected: "#ff6c37",
+    calendarDayWithTasks: "#00a86b",
+    // Green
+    calendarDayOtherMonth: "#9e9e9e",
+    taskBorder: "#e0e0e0",
+    taskHeader: "#ff6c37",
+    taskCheckboxEmpty: "#9e9e9e",
+    taskCheckboxFilled: "#00a86b",
+    taskStateTodo: "#212121",
+    taskStateCompleted: "#9e9e9e",
+    taskStateDelegated: "#6554c0",
+    // Purple
+    taskStateDelayed: "#ffab00",
+    // Amber
+    taskIndent: "#e0e0e0",
+    timelineBorder: "#e0e0e0",
+    timelineHeader: "#ff6c37",
+    timelineTimestamp: "#9e9e9e",
+    timelineEventCreated: "#ff6c37",
+    timelineEventStarted: "#ffab00",
+    timelineEventCompleted: "#00a86b",
+    timelineEventDelegated: "#6554c0",
+    timelineEventDelayed: "#ff3333",
+    // Red
+    separator: "#e0e0e0",
+    keyboardHint: "#9e9e9e",
+    helpDialogBorder: "#ff6c37",
+    focusIndicator: "#ff6c37",
+    modalOverlay: "#f5f5f5",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/cursor.ts
+var cursorTheme = {
+  name: "cursor",
+  colors: {
+    background: "#1e1e1e",
+    // VS Code default dark background
+    foreground: "#cccccc",
+    border: "#3c3c3c",
+    calendarBorder: "#3c3c3c",
+    calendarHeader: "#569cd6",
+    // VS Code blue
+    calendarToday: "#569cd6",
+    calendarSelected: "#569cd6",
+    calendarDayWithTasks: "#4ec9b0",
+    // Teal
+    calendarDayOtherMonth: "#6e7681",
+    taskBorder: "#3c3c3c",
+    taskHeader: "#569cd6",
+    taskCheckboxEmpty: "#6e7681",
+    taskCheckboxFilled: "#4ec9b0",
+    taskStateTodo: "#cccccc",
+    taskStateCompleted: "#6e7681",
+    taskStateDelegated: "#c586c0",
+    // Purple
+    taskStateDelayed: "#ce9178",
+    // Orange
+    taskIndent: "#3c3c3c",
+    timelineBorder: "#3c3c3c",
+    timelineHeader: "#569cd6",
+    timelineTimestamp: "#6e7681",
+    timelineEventCreated: "#569cd6",
+    timelineEventStarted: "#dcdcaa",
+    // Yellow
+    timelineEventCompleted: "#4ec9b0",
+    timelineEventDelegated: "#c586c0",
+    timelineEventDelayed: "#f14c4c",
+    // Red
+    separator: "#3c3c3c",
+    keyboardHint: "#6e7681",
+    helpDialogBorder: "#569cd6",
+    focusIndicator: "#569cd6",
+    modalOverlay: "#0d0d0d",
+    modalBackground: "#252526"
+    // VS Code sidebar
+  }
+};
+
+// src/themes/cursorLight.ts
+var cursorLightTheme = {
+  name: "cursor-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#1e1e1e",
+    border: "#e0e0e0",
+    calendarBorder: "#e0e0e0",
+    calendarHeader: "#0066b8",
+    // VS Code Blue
+    calendarToday: "#0066b8",
+    calendarSelected: "#0066b8",
+    calendarDayWithTasks: "#22863a",
+    // Green
+    calendarDayOtherMonth: "#a0a0a0",
+    taskBorder: "#e0e0e0",
+    taskHeader: "#0066b8",
+    taskCheckboxEmpty: "#a0a0a0",
+    taskCheckboxFilled: "#0066b8",
+    taskStateTodo: "#1e1e1e",
+    taskStateCompleted: "#a0a0a0",
+    taskStateDelegated: "#6f42c1",
+    // Purple
+    taskStateDelayed: "#d29922",
+    // Orange/Yellow
+    taskIndent: "#e0e0e0",
+    timelineBorder: "#e0e0e0",
+    timelineHeader: "#0066b8",
+    timelineTimestamp: "#a0a0a0",
+    timelineEventCreated: "#0066b8",
+    timelineEventStarted: "#d29922",
+    timelineEventCompleted: "#22863a",
+    timelineEventDelegated: "#6f42c1",
+    timelineEventDelayed: "#cb2431",
+    // Red
+    separator: "#e0e0e0",
+    keyboardHint: "#a0a0a0",
+    helpDialogBorder: "#0066b8",
+    focusIndicator: "#0066b8",
+    modalOverlay: "#f3f3f3",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/x.ts
+var xTheme = {
+  name: "x",
+  colors: {
+    background: "#15202b",
+    // X Dim background
+    foreground: "#f7f9f9",
+    border: "#38444d",
+    calendarBorder: "#38444d",
+    calendarHeader: "#1d9bf0",
+    // X Blue
+    calendarToday: "#1d9bf0",
+    calendarSelected: "#1d9bf0",
+    calendarDayWithTasks: "#00ba7c",
+    // Green
+    calendarDayOtherMonth: "#8b98a5",
+    // Secondary text
+    taskBorder: "#38444d",
+    taskHeader: "#1d9bf0",
+    taskCheckboxEmpty: "#8b98a5",
+    taskCheckboxFilled: "#00ba7c",
+    taskStateTodo: "#f7f9f9",
+    taskStateCompleted: "#8b98a5",
+    taskStateDelegated: "#7856ff",
+    // Purple
+    taskStateDelayed: "#f4212e",
+    // Red
+    taskIndent: "#38444d",
+    timelineBorder: "#38444d",
+    timelineHeader: "#1d9bf0",
+    timelineTimestamp: "#8b98a5",
+    timelineEventCreated: "#1d9bf0",
+    timelineEventStarted: "#ffad1f",
+    // Yellow
+    timelineEventCompleted: "#00ba7c",
+    timelineEventDelegated: "#7856ff",
+    timelineEventDelayed: "#f4212e",
+    separator: "#38444d",
+    keyboardHint: "#8b98a5",
+    helpDialogBorder: "#1d9bf0",
+    focusIndicator: "#1d9bf0",
+    modalOverlay: "#5b708366",
+    // X dim overlay style
+    modalBackground: "#1e2d3d"
+  }
+};
+
+// src/themes/xLight.ts
+var xLightTheme = {
+  name: "x-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#0f1419",
+    // Twitter black text
+    border: "#eff3f4",
+    calendarBorder: "#eff3f4",
+    calendarHeader: "#1d9bf0",
+    // X Blue
+    calendarToday: "#1d9bf0",
+    calendarSelected: "#1d9bf0",
+    calendarDayWithTasks: "#00ba7c",
+    // Green
+    calendarDayOtherMonth: "#536471",
+    // Gray
+    taskBorder: "#eff3f4",
+    taskHeader: "#1d9bf0",
+    taskCheckboxEmpty: "#536471",
+    taskCheckboxFilled: "#00ba7c",
+    taskStateTodo: "#0f1419",
+    taskStateCompleted: "#536471",
+    taskStateDelegated: "#7856ff",
+    // Purple
+    taskStateDelayed: "#f4212e",
+    // Red (delayed = urgent)
+    taskIndent: "#eff3f4",
+    timelineBorder: "#eff3f4",
+    timelineHeader: "#1d9bf0",
+    timelineTimestamp: "#536471",
+    timelineEventCreated: "#1d9bf0",
+    timelineEventStarted: "#ffad1f",
+    // Yellow
+    timelineEventCompleted: "#00ba7c",
+    timelineEventDelegated: "#7856ff",
+    timelineEventDelayed: "#f4212e",
+    separator: "#eff3f4",
+    keyboardHint: "#536471",
+    helpDialogBorder: "#1d9bf0",
+    focusIndicator: "#1d9bf0",
+    modalOverlay: "#00000033",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/instagram.ts
+var instagramTheme = {
+  name: "instagram",
+  colors: {
+    background: "#121212",
+    foreground: "#fafafa",
+    border: "#262626",
+    calendarBorder: "#262626",
+    calendarHeader: "#e1306c",
+    // Instagram gradient pinkish
+    calendarToday: "#0095f6",
+    // Instagram blue
+    calendarSelected: "#0095f6",
+    calendarDayWithTasks: "#0095f6",
+    calendarDayOtherMonth: "#8e8e8e",
+    taskBorder: "#262626",
+    taskHeader: "#e1306c",
+    taskCheckboxEmpty: "#8e8e8e",
+    taskCheckboxFilled: "#0095f6",
+    taskStateTodo: "#fafafa",
+    taskStateCompleted: "#8e8e8e",
+    taskStateDelegated: "#833ab4",
+    // Purple from gradient
+    taskStateDelayed: "#fca1cc",
+    // Orange/Yellow ish
+    taskIndent: "#262626",
+    timelineBorder: "#262626",
+    timelineHeader: "#e1306c",
+    timelineTimestamp: "#8e8e8e",
+    timelineEventCreated: "#0095f6",
+    timelineEventStarted: "#f56040",
+    timelineEventCompleted: "#0095f6",
+    timelineEventDelegated: "#833ab4",
+    timelineEventDelayed: "#fd1d1d",
+    separator: "#262626",
+    keyboardHint: "#8e8e8e",
+    helpDialogBorder: "#e1306c",
+    focusIndicator: "#e1306c",
+    modalOverlay: "#00000080",
+    modalBackground: "#262626"
+  }
+};
+
+// src/themes/instagramLight.ts
+var instagramLightTheme = {
+  name: "instagram-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#262626",
+    border: "#dbdbdb",
+    calendarBorder: "#dbdbdb",
+    calendarHeader: "#e1306c",
+    // Instagram pink
+    calendarToday: "#0095f6",
+    // Instagram blue
+    calendarSelected: "#0095f6",
+    calendarDayWithTasks: "#0095f6",
+    calendarDayOtherMonth: "#8e8e8e",
+    taskBorder: "#dbdbdb",
+    taskHeader: "#e1306c",
+    taskCheckboxEmpty: "#8e8e8e",
+    taskCheckboxFilled: "#0095f6",
+    taskStateTodo: "#262626",
+    taskStateCompleted: "#8e8e8e",
+    taskStateDelegated: "#833ab4",
+    // Purple gradient
+    taskStateDelayed: "#fd1d1d",
+    // Red
+    taskIndent: "#dbdbdb",
+    timelineBorder: "#dbdbdb",
+    timelineHeader: "#e1306c",
+    timelineTimestamp: "#8e8e8e",
+    timelineEventCreated: "#0095f6",
+    timelineEventStarted: "#f56040",
+    // Orange
+    timelineEventCompleted: "#0095f6",
+    timelineEventDelegated: "#833ab4",
+    timelineEventDelayed: "#fd1d1d",
+    separator: "#dbdbdb",
+    keyboardHint: "#8e8e8e",
+    helpDialogBorder: "#e1306c",
+    focusIndicator: "#e1306c",
+    modalOverlay: "#00000066",
+    modalBackground: "#ffffff"
+  }
+};
+
+// src/themes/amazon.ts
+var amazonTheme = {
+  name: "amazon",
+  colors: {
+    background: "#131A22",
+    foreground: "#ffffff",
+    border: "#232f3e",
+    calendarBorder: "#232f3e",
+    calendarHeader: "#ff9900",
+    // Amazon Orange
+    calendarToday: "#ff9900",
+    calendarSelected: "#ff9900",
+    calendarDayWithTasks: "#ff9900",
+    calendarDayOtherMonth: "#3a4553",
+    taskBorder: "#232f3e",
+    taskHeader: "#ff9900",
+    taskCheckboxEmpty: "#3a4553",
+    taskCheckboxFilled: "#ff9900",
+    taskStateTodo: "#ffffff",
+    taskStateCompleted: "#565959",
+    taskStateDelegated: "#146eb4",
+    // Amazon Prime blueish
+    taskStateDelayed: "#ff9900",
+    taskIndent: "#232f3e",
+    timelineBorder: "#232f3e",
+    timelineHeader: "#ff9900",
+    timelineTimestamp: "#565959",
+    timelineEventCreated: "#ff9900",
+    timelineEventStarted: "#ff9900",
+    timelineEventCompleted: "#ff9900",
+    timelineEventDelegated: "#146eb4",
+    timelineEventDelayed: "#cc0c39",
+    separator: "#232f3e",
+    keyboardHint: "#565959",
+    helpDialogBorder: "#ff9900",
+    focusIndicator: "#ff9900",
+    modalOverlay: "#00000099",
+    modalBackground: "#232f3e"
+  }
+};
+
+// src/themes/amazonLight.ts
+var amazonLightTheme = {
+  name: "amazon-light",
+  colors: {
+    background: "#ffffff",
+    foreground: "#0f1111",
+    border: "#ddd",
+    calendarBorder: "#ddd",
+    calendarHeader: "#ff9900",
+    // Amazon Orange
+    calendarToday: "#ff9900",
+    calendarSelected: "#ff9900",
+    calendarDayWithTasks: "#ff9900",
+    calendarDayOtherMonth: "#565959",
+    taskBorder: "#ddd",
+    taskHeader: "#ff9900",
+    taskCheckboxEmpty: "#565959",
+    taskCheckboxFilled: "#ff9900",
+    taskStateTodo: "#0f1111",
+    taskStateCompleted: "#565959",
+    taskStateDelegated: "#146eb4",
+    // Amazon Prime blue
+    taskStateDelayed: "#b12704",
+    // Amazon red/warning
+    taskIndent: "#ddd",
+    timelineBorder: "#ddd",
+    timelineHeader: "#ff9900",
+    timelineTimestamp: "#565959",
+    timelineEventCreated: "#ff9900",
+    timelineEventStarted: "#ff9900",
+    timelineEventCompleted: "#007600",
+    // Amazon green (success)
+    timelineEventDelegated: "#146eb4",
+    timelineEventDelayed: "#b12704",
+    separator: "#ddd",
+    keyboardHint: "#565959",
+    helpDialogBorder: "#ff9900",
+    focusIndicator: "#ff9900",
+    modalOverlay: "#00000033",
+    modalBackground: "#f7f8f8"
+  }
+};
+
+// src/themes/apple.ts
+var appleTheme = {
+  name: "apple",
+  colors: {
+    background: "#1c1c1e",
+    // System Background Dark
+    foreground: "#ffffff",
+    border: "#38383a",
+    // System Gray 5 Dark
+    calendarBorder: "#38383a",
+    calendarHeader: "#0a84ff",
+    // System Blue Dark
+    calendarToday: "#0a84ff",
+    calendarSelected: "#0a84ff",
+    calendarDayWithTasks: "#30d158",
+    // System Green Dark
+    calendarDayOtherMonth: "#636366",
+    // System Gray 3 Dark
+    taskBorder: "#38383a",
+    taskHeader: "#0a84ff",
+    taskCheckboxEmpty: "#636366",
+    taskCheckboxFilled: "#30d158",
+    taskStateTodo: "#ffffff",
+    taskStateCompleted: "#8e8e93",
+    // System Gray Dark
+    taskStateDelegated: "#bf5af2",
+    // System Purple Dark
+    taskStateDelayed: "#ff9f0a",
+    // System Orange Dark
+    taskIndent: "#48484a",
+    // System Gray 4 Dark
+    timelineBorder: "#38383a",
+    timelineHeader: "#0a84ff",
+    timelineTimestamp: "#8e8e93",
+    timelineEventCreated: "#0a84ff",
+    timelineEventStarted: "#ff9f0a",
+    timelineEventCompleted: "#30d158",
+    timelineEventDelegated: "#bf5af2",
+    timelineEventDelayed: "#ff453a",
+    // System Red Dark
+    separator: "#38383a",
+    keyboardHint: "#8e8e93",
+    helpDialogBorder: "#0a84ff",
+    focusIndicator: "#0a84ff",
+    modalOverlay: "#00000066",
+    modalBackground: "#2c2c2e"
+    // System Gray 5 Dark
+  }
+};
+
+// src/themes/appleLight.ts
+var appleLightTheme = {
+  name: "apple-light",
+  colors: {
+    background: "#ffffff",
+    // System Background Light
+    foreground: "#000000",
+    border: "#d1d1d6",
+    // System Gray 4 Light
+    calendarBorder: "#d1d1d6",
+    calendarHeader: "#007aff",
+    // System Blue Light
+    calendarToday: "#007aff",
+    calendarSelected: "#007aff",
+    calendarDayWithTasks: "#34c759",
+    // System Green Light
+    calendarDayOtherMonth: "#8e8e93",
+    // System Gray Light
+    taskBorder: "#d1d1d6",
+    taskHeader: "#007aff",
+    taskCheckboxEmpty: "#8e8e93",
+    taskCheckboxFilled: "#34c759",
+    taskStateTodo: "#000000",
+    taskStateCompleted: "#8e8e93",
+    taskStateDelegated: "#af52de",
+    // System Purple Light
+    taskStateDelayed: "#ff9500",
+    // System Orange Light
+    taskIndent: "#c7c7cc",
+    timelineBorder: "#d1d1d6",
+    timelineHeader: "#007aff",
+    timelineTimestamp: "#8e8e93",
+    timelineEventCreated: "#007aff",
+    timelineEventStarted: "#ff9500",
+    timelineEventCompleted: "#34c759",
+    timelineEventDelegated: "#af52de",
+    timelineEventDelayed: "#ff3b30",
+    // System Red Light
+    separator: "#d1d1d6",
+    keyboardHint: "#8e8e93",
+    helpDialogBorder: "#007aff",
+    focusIndicator: "#007aff",
+    modalOverlay: "#00000033",
+    modalBackground: "#f2f2f7"
+    // System Gray 6 Light
+  }
+};
+
+// src/themes/batman.ts
+var batmanTheme = {
+  name: "batman",
+  colors: {
+    background: "#000000",
+    foreground: "#d6d6d6",
+    border: "#333333",
+    calendarBorder: "#333333",
+    calendarHeader: "#ffff00",
+    // Bright Yellow
+    calendarToday: "#ffff00",
+    calendarSelected: "#ffff00",
+    calendarDayWithTasks: "#ffff00",
+    calendarDayOtherMonth: "#444444",
+    taskBorder: "#333333",
+    taskHeader: "#ffff00",
+    taskCheckboxEmpty: "#444444",
+    taskCheckboxFilled: "#ffff00",
+    taskStateTodo: "#d6d6d6",
+    taskStateCompleted: "#555555",
+    taskStateDelegated: "#2a3c5f",
+    // Dark Knight Blue
+    taskStateDelayed: "#e6aa5f",
+    // Goldish
+    taskIndent: "#333333",
+    timelineBorder: "#333333",
+    timelineHeader: "#ffff00",
+    timelineTimestamp: "#555555",
+    timelineEventCreated: "#ffff00",
+    timelineEventStarted: "#e6aa5f",
+    timelineEventCompleted: "#ffff00",
+    timelineEventDelegated: "#2a3c5f",
+    timelineEventDelayed: "#8c541c",
+    separator: "#333333",
+    keyboardHint: "#444444",
+    helpDialogBorder: "#ffff00",
+    focusIndicator: "#ffff00",
+    modalOverlay: "#00000099",
+    modalBackground: "#1a1a1a"
+  }
+};
+
+// src/themes/spiderman.ts
+var spidermanTheme = {
+  name: "spiderman",
+  colors: {
+    background: "#101820",
+    // Very dark blueish black
+    foreground: "#e0e0e0",
+    border: "#2B3784",
+    // Spidey Blue
+    calendarBorder: "#2B3784",
+    calendarHeader: "#DF1F2D",
+    // Spidey Red
+    calendarToday: "#DF1F2D",
+    calendarSelected: "#DF1F2D",
+    calendarDayWithTasks: "#DF1F2D",
+    calendarDayOtherMonth: "#4a4a4a",
+    taskBorder: "#2B3784",
+    taskHeader: "#DF1F2D",
+    taskCheckboxEmpty: "#2B3784",
+    taskCheckboxFilled: "#DF1F2D",
+    taskStateTodo: "#e0e0e0",
+    taskStateCompleted: "#4a4a4a",
+    taskStateDelegated: "#2B3784",
+    taskStateDelayed: "#a71814",
+    taskIndent: "#2B3784",
+    timelineBorder: "#2B3784",
+    timelineHeader: "#DF1F2D",
+    timelineTimestamp: "#4a4a4a",
+    timelineEventCreated: "#DF1F2D",
+    timelineEventStarted: "#DF1F2D",
+    timelineEventCompleted: "#DF1F2D",
+    timelineEventDelegated: "#2B3784",
+    timelineEventDelayed: "#a71814",
+    separator: "#2B3784",
+    keyboardHint: "#4a4a4a",
+    helpDialogBorder: "#DF1F2D",
+    focusIndicator: "#DF1F2D",
+    modalOverlay: "#000000cc",
+    modalBackground: "#1d2a38"
+  }
+};
+
+// src/themes/index.ts
+var lightThemes = {
+  light: lightTheme,
+  claude: claudeTheme,
+  "apple-light": appleLightTheme,
+  "github-light": githubLightTheme,
+  "catppuccin-latte": catppuccinLatteTheme,
+  "ubuntu-light": ubuntuLightTheme,
+  "atom-light": atomOneLightTheme,
+  "intellij-light": intellijLightTheme,
+  "nord-light": nordLightTheme,
+  "postman-light": postmanLightTheme,
+  "cursor-light": cursorLightTheme,
+  "x-light": xLightTheme,
+  "instagram-light": instagramLightTheme,
+  "amazon-light": amazonLightTheme
+};
+var darkThemes = {
+  dark: darkTheme,
+  terminal: terminalTheme,
+  apple: appleTheme,
+  "github-dark": githubDarkTheme,
+  catppuccin: catppuccinTheme,
+  ubuntu: ubuntuTheme,
+  atom: atomOneDarkTheme,
+  intellij: intellijTheme,
+  nord: nordTheme,
+  postman: postmanTheme,
+  cursor: cursorTheme,
+  x: xTheme,
+  instagram: instagramTheme,
+  amazon: amazonTheme,
+  batman: batmanTheme,
+  spiderman: spidermanTheme
+};
+var themes = {
+  ...lightThemes,
+  ...darkThemes
+};
+var getTheme = (name) => {
+  return themes[name] || themes.dark;
+};
+var getThemeNames = () => {
+  return Object.keys(themes);
+};
+var getLightThemeNames = () => {
+  return Object.keys(lightThemes);
+};
+var getDarkThemeNames = () => {
+  return Object.keys(darkThemes);
+};
+
+// src/contexts/StorageContext.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useRef,
+  useState,
+  useCallback
+} from "react";
+
+// src/services/storage.ts
+import { promises as fs } from "fs";
+import { dirname } from "path";
+import { homedir } from "os";
+var getStoragePath = () => {
+  const home = homedir();
+  const platform = process.platform;
+  if (platform === "darwin") {
+    return `${home}/Library/Application Support/epoch/data.json`;
+  } else if (platform === "linux") {
+    return `${home}/.config/epoch/data.json`;
+  } else if (platform === "win32") {
+    const appData = process.env.APPDATA || `${home}\\AppData\\Roaming`;
+    return `${appData}\\epoch\\data.json`;
+  }
+  return `${home}/.epoch/data.json`;
+};
+var getDefaultSchema = () => ({
+  version: "1.0.0",
+  tasks: {},
+  timeline: {},
+  settings: {
+    theme: "dark",
+    defaultStartTime: "now",
+    dateFormat: "MMMM do, yyyy",
+    timeFormat: "12h"
+  }
+});
+var StorageService = class {
+  constructor(filePath) {
+    this.filePath = filePath || getStoragePath();
+  }
+  async load() {
+    try {
+      const data = await fs.readFile(this.filePath, "utf-8");
+      const parsed = JSON.parse(data);
+      return this.hydrateDates(parsed);
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return getDefaultSchema();
+      }
+      console.error("Failed to load storage:", error);
+      return getDefaultSchema();
+    }
+  }
+  async save(data) {
+    try {
+      const dir = dirname(this.filePath);
+      await fs.mkdir(dir, { recursive: true });
+      const serialized = this.serializeDates(data);
+      await fs.writeFile(
+        this.filePath,
+        JSON.stringify(serialized, null, 2),
+        "utf-8"
+      );
+    } catch (error) {
+      console.error("Failed to save storage:", error);
+    }
+  }
+  async backup() {
+    try {
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/:/g, "-");
+      const backupPath = `${this.filePath}.backup-${timestamp}`;
+      const data = await fs.readFile(this.filePath, "utf-8");
+      await fs.writeFile(backupPath, data, "utf-8");
+    } catch (error) {
+      console.error("Failed to backup storage:", error);
+    }
+  }
+  getStoragePath() {
+    return this.filePath;
+  }
+  hydrateDates(data) {
+    if (data.tasks) {
+      Object.keys(data.tasks).forEach((date) => {
+        data.tasks[date] = data.tasks[date].map(
+          (task) => this.hydrateTask(task)
+        );
+      });
+    }
+    if (data.timeline) {
+      Object.keys(data.timeline).forEach((date) => {
+        data.timeline[date] = data.timeline[date].map((event) => ({
+          ...event,
+          timestamp: new Date(event.timestamp),
+          previousState: event.previousState,
+          newState: event.newState
+        }));
+      });
+    }
+    return data;
+  }
+  hydrateTask(task) {
+    return {
+      ...task,
+      createdAt: new Date(task.createdAt),
+      updatedAt: new Date(task.updatedAt),
+      startTime: task.startTime ? new Date(task.startTime) : void 0,
+      endTime: task.endTime ? new Date(task.endTime) : void 0,
+      children: task.children ? task.children.map((child) => this.hydrateTask(child)) : []
+    };
+  }
+  serializeDates(data) {
+    return {
+      ...data,
+      tasks: Object.keys(data.tasks).reduce((acc, date) => {
+        acc[date] = data.tasks[date].map((task) => this.serializeTask(task));
+        return acc;
+      }, {}),
+      timeline: Object.keys(data.timeline).reduce((acc, date) => {
+        acc[date] = data.timeline[date].map((event) => ({
+          ...event,
+          timestamp: event.timestamp.toISOString()
+        }));
+        return acc;
+      }, {})
+    };
+  }
+  serializeTask(task) {
+    return {
+      ...task,
+      createdAt: task.createdAt.toISOString(),
+      updatedAt: task.updatedAt.toISOString(),
+      startTime: task.startTime ? task.startTime.toISOString() : void 0,
+      endTime: task.endTime ? task.endTime.toISOString() : void 0,
+      children: task.children ? task.children.map((child) => this.serializeTask(child)) : []
+    };
+  }
+};
+var storageService = new StorageService();
+
+// src/contexts/StorageContext.tsx
+import { jsx } from "react/jsx-runtime";
+var StorageContext = createContext(void 0);
+var StorageProvider = ({
+  children
+}) => {
+  const [data, setData] = useState(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const saveTimeoutRef = useRef(void 0);
+  const latestDataRef = useRef(null);
+  useEffect(() => {
+    const loadData = async () => {
+      try {
+        setIsLoading(true);
+        const loadedData = await storageService.load();
+        setData(loadedData);
+        latestDataRef.current = loadedData;
+        setError(null);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Unknown error"));
+      } finally {
+        setIsLoading(false);
+      }
+    };
+    loadData();
+  }, []);
+  const save = useCallback(async (newData) => {
+    setData(newData);
+    latestDataRef.current = newData;
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    saveTimeoutRef.current = setTimeout(async () => {
+      try {
+        await storageService.save(newData);
+      } catch (err) {
+        setError(err instanceof Error ? err : new Error("Failed to save"));
+      }
+    }, 500);
+  }, []);
+  const saveNow = useCallback(async () => {
+    if (saveTimeoutRef.current) {
+      clearTimeout(saveTimeoutRef.current);
+    }
+    if (latestDataRef.current) {
+      try {
+        await storageService.save(latestDataRef.current);
+      } catch (err) {
+        console.error("Failed to save:", err);
+      }
+    }
+  }, []);
+  useEffect(() => {
+    return () => {
+      if (saveTimeoutRef.current) {
+        clearTimeout(saveTimeoutRef.current);
+      }
+      if (latestDataRef.current) {
+        storageService.save(latestDataRef.current).catch((err) => {
+          console.error("Failed to save on unmount:", err);
+        });
+      }
+    };
+  }, []);
+  return /* @__PURE__ */ jsx(StorageContext.Provider, { value: { data, isLoading, error, save, saveNow }, children });
+};
+var useStorage = () => {
+  const context = useContext(StorageContext);
+  if (!context) {
+    throw new Error("useStorage must be used within StorageProvider");
+  }
+  return context;
+};
+
+// src/contexts/ThemeContext.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+var ThemeContext = createContext2(void 0);
+var ThemeProvider = ({
+  children,
+  initialTheme = "dark"
+}) => {
+  const { data, save } = useStorage();
+  const [themeName, setThemeName] = useState2(initialTheme);
+  const theme = getTheme(themeName);
+  useEffect2(() => {
+    if (data?.settings?.theme) {
+      setThemeName(data.settings.theme);
+    }
+  }, [data?.settings?.theme]);
+  const handleSetTheme = (name) => {
+    if (getThemeNames().includes(name)) {
+      setThemeName(name);
+      if (data) {
+        save({
+          ...data,
+          settings: {
+            ...data.settings,
+            theme: name
+          }
+        });
+      }
+    }
+  };
+  return /* @__PURE__ */ jsx2(
+    ThemeContext.Provider,
+    {
+      value: {
+        theme,
+        themeName,
+        setTheme: handleSetTheme,
+        availableThemes: getThemeNames()
+      },
+      children
+    }
+  );
+};
+var useTheme = () => {
+  const context = useContext2(ThemeContext);
+  if (!context) {
+    throw new Error("useTheme must be used within ThemeProvider");
+  }
+  return context;
+};
+
+// src/contexts/AppContext.tsx
+import {
+  createContext as createContext3,
+  useContext as useContext3,
+  useEffect as useEffect3,
+  useState as useState3,
+  useRef as useRef2,
+  useCallback as useCallback2
+} from "react";
+import { jsx as jsx3 } from "react/jsx-runtime";
+var AppContext = createContext3(void 0);
+var AppProvider = ({ children }) => {
+  const { data, save, saveNow } = useStorage();
+  const today = /* @__PURE__ */ new Date();
+  const [selectedDate, setSelectedDate] = useState3({
+    year: today.getFullYear(),
+    month: today.getMonth(),
+    day: today.getDate()
+  });
+  const [tasks, setTasks] = useState3({});
+  const [timeline, setTimeline] = useState3(
+    {}
+  );
+  const [activePane, setActivePane] = useState3("tasks");
+  const [showHelp, setShowHelp] = useState3(false);
+  const isInputModeRef = useRef2(false);
+  const [isInputModeState, setIsInputModeState] = useState3(false);
+  const [showOverview, setShowOverview] = useState3(false);
+  const setIsInputMode = useCallback2((mode) => {
+    isInputModeRef.current = mode;
+    setIsInputModeState(mode);
+  }, []);
+  const isInputMode = isInputModeRef.current;
+  const [overviewMonth, setOverviewMonth] = useState3({
+    year: today.getFullYear(),
+    month: today.getMonth()
+  });
+  const [exitConfirmation, setExitConfirmation] = useState3(false);
+  const [showThemeDialog, setShowThemeDialog] = useState3(false);
+  const [showClearTimelineDialog, setShowClearTimelineDialog] = useState3(false);
+  const clearTimelineForDate = useCallback2((dateStr) => {
+    setTimeline((prev) => {
+      const newTimeline = { ...prev };
+      delete newTimeline[dateStr];
+      return newTimeline;
+    });
+  }, []);
+  const initialLoadDone = useRef2(false);
+  const dataRef = useRef2(data);
+  const saveRef = useRef2(save);
+  useEffect3(() => {
+    dataRef.current = data;
+    saveRef.current = save;
+  }, [data, save]);
+  useEffect3(() => {
+    if (data && !initialLoadDone.current) {
+      setTasks(data.tasks);
+      setTimeline(data.timeline);
+      initialLoadDone.current = true;
+    }
+  }, [data]);
+  useEffect3(() => {
+    if (initialLoadDone.current && dataRef.current) {
+      saveRef.current({
+        ...dataRef.current,
+        tasks,
+        timeline
+      });
+    }
+  }, [tasks, timeline]);
+  return /* @__PURE__ */ jsx3(
+    AppContext.Provider,
+    {
+      value: {
+        selectedDate,
+        setSelectedDate,
+        tasks,
+        setTasks,
+        timeline,
+        setTimeline,
+        activePane,
+        setActivePane,
+        showHelp,
+        setShowHelp,
+        isInputMode,
+        setIsInputMode,
+        showOverview,
+        setShowOverview,
+        overviewMonth,
+        setOverviewMonth,
+        exitConfirmation,
+        setExitConfirmation,
+        showThemeDialog,
+        setShowThemeDialog,
+        showClearTimelineDialog,
+        setShowClearTimelineDialog,
+        clearTimelineForDate,
+        isModalOpen: showHelp || showThemeDialog || showOverview || showClearTimelineDialog,
+        saveNow
+      },
+      children
+    }
+  );
+};
+var useApp = () => {
+  const context = useContext3(AppContext);
+  if (!context) {
+    throw new Error("useApp must be used within AppProvider");
+  }
+  return context;
+};
+
+// src/hooks/useKeyboardNav.ts
+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 } = useApp();
+  useEffect4(() => {
+    if (exitConfirmation) {
+      const timer = setTimeout(() => {
+        setExitConfirmation(false);
+      }, 3e3);
+      return () => clearTimeout(timer);
+    }
+  }, [exitConfirmation, setExitConfirmation]);
+  const isActive = !isInputMode && !showThemeDialog && !showClearTimelineDialog;
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      if (exitConfirmation) {
+        saveNow().then(() => {
+          const inkApp = global.__inkApp;
+          if (inkApp) {
+            inkApp.unmount();
+          }
+          setTimeout(() => {
+            console.clear();
+            process.stdout.write("\x1Bc");
+            process.exit(0);
+          }, 100);
+        }).catch(() => {
+          const inkApp = global.__inkApp;
+          if (inkApp) {
+            inkApp.unmount();
+          }
+          setTimeout(() => {
+            console.clear();
+            process.stdout.write("\x1Bc");
+            process.exit(0);
+          }, 100);
+        });
+        return;
+      } else {
+        setExitConfirmation(true);
+        return;
+      }
+    }
+    if (input === ":") {
+      setShowOverview(!showOverview);
+      return;
+    }
+    if (input === "?") {
+      setShowHelp(!showHelp);
+      return;
+    }
+    if (key.ctrl && input === "t") {
+      setShowThemeDialog(true);
+      return;
+    }
+    if (input === "C" && activePane === "timeline") {
+      setShowClearTimelineDialog(true);
+      return;
+    }
+    if (input === "1") {
+      setActivePane("calendar");
+      return;
+    }
+    if (input === "2" || key.tab && !key.shift) {
+      setActivePane("tasks");
+      return;
+    }
+    if (input === "3" || key.tab && key.shift) {
+      setActivePane("timeline");
+      return;
+    }
+  }, {
+    // Disable this hook when in input mode or dialogs are open to prevent interference with TextInput
+    isActive
+  });
+};
+
+// src/hooks/useTerminalSize.ts
+import { useState as useState4, useEffect as useEffect5 } from "react";
+import { useStdout } from "ink";
+var useTerminalSize = () => {
+  const { stdout } = useStdout();
+  const [size, setSize] = useState4({
+    width: stdout?.columns || 100,
+    height: stdout?.rows || 30
+  });
+  useEffect5(() => {
+    if (!stdout) return;
+    setSize({
+      width: stdout.columns || 100,
+      height: stdout.rows || 30
+    });
+    const handleResize = () => {
+      setSize({
+        width: stdout.columns || 100,
+        height: stdout.rows || 30
+      });
+    };
+    stdout.on("resize", handleResize);
+    return () => {
+      stdout.off("resize", handleResize);
+    };
+  }, [stdout]);
+  return size;
+};
+
+// src/components/layout/ThreeColumnLayout.tsx
+import { Box, Text } from "ink";
+import { jsx as jsx4, jsxs } from "react/jsx-runtime";
+var VerticalSeparator = ({ color, backgroundColor, height, isFocused }) => {
+  const char = isFocused ? "\u2503" : "\u2502";
+  const lines = height ? Array(height).fill(char) : [char];
+  return /* @__PURE__ */ jsx4(Box, { flexDirection: "column", backgroundColor, children: lines.map((c, i) => /* @__PURE__ */ jsx4(Text, { color, backgroundColor, children: c }, i)) });
+};
+var ThreeColumnLayout = ({
+  leftPane,
+  centerPane,
+  rightPane,
+  leftWidth = "15%",
+  rightWidth = "25%",
+  height,
+  activePane
+}) => {
+  const { theme } = useTheme();
+  const focusedColor = theme.colors.focusIndicator;
+  const normalColor = theme.colors.border;
+  const bgColor = theme.name !== "terminal" ? theme.colors.background : void 0;
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "row",
+      width: "100%",
+      height,
+      backgroundColor: bgColor,
+      children: [
+        /* @__PURE__ */ jsx4(
+          Box,
+          {
+            width: leftWidth,
+            flexShrink: 0,
+            flexDirection: "column",
+            backgroundColor: bgColor,
+            children: leftPane
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          VerticalSeparator,
+          {
+            isFocused: activePane === "calendar" || activePane === "tasks",
+            color: activePane === "calendar" || activePane === "tasks" ? focusedColor : normalColor,
+            backgroundColor: bgColor,
+            height
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          Box,
+          {
+            flexGrow: 1,
+            flexShrink: 1,
+            flexDirection: "column",
+            backgroundColor: bgColor,
+            children: centerPane
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          VerticalSeparator,
+          {
+            isFocused: activePane === "tasks" || activePane === "timeline",
+            color: activePane === "tasks" || activePane === "timeline" ? focusedColor : normalColor,
+            backgroundColor: bgColor,
+            height
+          }
+        ),
+        /* @__PURE__ */ jsx4(
+          Box,
+          {
+            width: rightWidth,
+            flexShrink: 0.3,
+            flexDirection: "column",
+            backgroundColor: bgColor,
+            children: rightPane
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/calendar/CalendarPane.tsx
+import { useState as useState5, useEffect as useEffect6 } from "react";
+import { Box as Box5, Text as Text3, useInput as useInput2 } from "ink";
+import { addDays, addWeeks, subDays, subWeeks } from "date-fns";
+
+// src/components/layout/Pane.tsx
+import { Box as Box2 } from "ink";
+
+// src/components/common/ThemedText.tsx
+import { Text as Text2 } from "ink";
+import { jsx as jsx5 } from "react/jsx-runtime";
+var ThemedText = ({
+  children,
+  backgroundColor,
+  ...props
+}) => {
+  const { theme } = useTheme();
+  const bgColor = backgroundColor ?? (theme.name !== "terminal" ? theme.colors.background : void 0);
+  return /* @__PURE__ */ jsx5(Text2, { ...props, backgroundColor: bgColor, children });
+};
+
+// src/components/layout/Pane.tsx
+import { jsx as jsx6, jsxs as jsxs2 } from "react/jsx-runtime";
+var Pane = ({
+  children,
+  title,
+  isFocused = false,
+  width,
+  height,
+  center = false
+}) => {
+  const { theme } = useTheme();
+  const paneHeight = height;
+  return /* @__PURE__ */ jsxs2(
+    Box2,
+    {
+      flexDirection: "column",
+      width,
+      height: paneHeight,
+      paddingRight: 1,
+      paddingX: 2,
+      alignItems: center ? "center" : "flex-start",
+      children: [
+        title && /* @__PURE__ */ jsx6(Box2, { marginBottom: 1, children: /* @__PURE__ */ jsx6(
+          ThemedText,
+          {
+            backgroundColor: isFocused ? theme.colors.focusIndicator : void 0,
+            color: isFocused ? theme.colors.background : theme.colors.taskHeader,
+            bold: true,
+            children: isFocused ? ` ${title.toUpperCase()} ` : title
+          }
+        ) }),
+        /* @__PURE__ */ jsx6(
+          Box2,
+          {
+            flexDirection: "column",
+            flexGrow: 1,
+            overflowY: "hidden",
+            alignItems: center ? "center" : "flex-start",
+            children
+          }
+        )
+      ]
+    }
+  );
+};
+
+// src/components/calendar/MonthView.tsx
+import { Box as Box4 } from "ink";
+
+// src/components/calendar/DayCell.tsx
+import { Box as Box3 } from "ink";
+import { jsx as jsx7, jsxs as jsxs3 } from "react/jsx-runtime";
+var DayCell = ({ day }) => {
+  const { theme } = useTheme();
+  let textColor = theme.colors.calendarDayOtherMonth;
+  if (day.isCurrentMonth) {
+    textColor = day.hasTasks ? theme.colors.calendarDayWithTasks : theme.colors.foreground;
+  }
+  const isSelected = day.isSelected;
+  const isToday2 = day.isToday && !day.isSelected;
+  if (isSelected) {
+    textColor = theme.colors.calendarSelected;
+  } else if (day.isToday) {
+    textColor = theme.colors.calendarToday;
+  }
+  const dayNum = day.date.day.toString().padStart(2, " ");
+  const leftBracket = isSelected ? "[" : isToday2 ? "(" : " ";
+  const rightBracket = isSelected ? "]" : isToday2 ? ")" : " ";
+  return /* @__PURE__ */ jsx7(Box3, { width: 4, children: /* @__PURE__ */ jsxs3(ThemedText, { color: textColor, children: [
+    leftBracket,
+    dayNum,
+    rightBracket
+  ] }) });
+};
+
+// src/components/calendar/MonthView.tsx
+import { jsx as jsx8, jsxs as jsxs4 } from "react/jsx-runtime";
+var MonthView = ({ calendarView }) => {
+  const { theme } = useTheme();
+  const dayHeaders = ["Mo", "Tu", "We", "Th", "Fr", "Sa", "Su"];
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx8(Box4, { marginBottom: 1, children: dayHeaders.map((day) => /* @__PURE__ */ jsx8(Box4, { width: 4, children: /* @__PURE__ */ jsx8(ThemedText, { color: theme.colors.calendarHeader, bold: true, children: day }) }, day)) }),
+    calendarView.weeks.map((week, weekIdx) => /* @__PURE__ */ jsx8(Box4, { marginBottom: 0, children: week.map((day) => /* @__PURE__ */ jsx8(DayCell, { day }, day.dateString)) }, weekIdx))
+  ] });
+};
+
+// 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) {
+    const weeks = generateMonthCalendar(year, month);
+    const calendarDays = weeks.map(
+      (week) => week.map((date) => this.createCalendarDay(date, selectedDate, tasks, month))
+    );
+    return {
+      year,
+      month,
+      weeks: calendarDays
+    };
+  }
+  createCalendarDay(date, selectedDate, tasks, currentMonth) {
+    const dateString = getDateString(date);
+    const dayTasks = tasks[dateString] || [];
+    return {
+      date: {
+        year: date.getFullYear(),
+        month: date.getMonth(),
+        day: date.getDate()
+      },
+      dateString,
+      isToday: isToday(date),
+      isSelected: this.isSameDay(date, selectedDate),
+      isCurrentMonth: date.getMonth() === currentMonth,
+      hasTasks: dayTasks.length > 0,
+      taskCount: dayTasks.length
+    };
+  }
+  isSameDay(date, calendarDate) {
+    return date.getDate() === calendarDate.day && date.getMonth() === calendarDate.month && date.getFullYear() === calendarDate.year;
+  }
+  getNextMonth(year, month) {
+    if (month === 11) {
+      return { year: year + 1, month: 0 };
+    }
+    return { year, month: month + 1 };
+  }
+  getPreviousMonth(year, month) {
+    if (month === 0) {
+      return { year: year - 1, month: 11 };
+    }
+    return { year, month: month - 1 };
+  }
+  getDayOfWeek(date) {
+    return date.getDay();
+  }
+  getMonthName(month) {
+    const months = [
+      "January",
+      "February",
+      "March",
+      "April",
+      "May",
+      "June",
+      "July",
+      "August",
+      "September",
+      "October",
+      "November",
+      "December"
+    ];
+    return months[month];
+  }
+};
+var calendarService = new CalendarService();
+
+// src/components/calendar/CalendarPane.tsx
+import { jsx as jsx9, jsxs as jsxs5 } from "react/jsx-runtime";
+var CalendarPane = () => {
+  const { theme } = useTheme();
+  const { selectedDate, setSelectedDate, tasks, activePane, isModalOpen, isInputMode } = useApp();
+  const [currentMonth, setCurrentMonth] = useState5({
+    year: selectedDate.year,
+    month: selectedDate.month
+  });
+  useEffect6(() => {
+    if (selectedDate.month !== currentMonth.month || selectedDate.year !== currentMonth.year) {
+      setCurrentMonth({ year: selectedDate.year, month: selectedDate.month });
+    }
+  }, [selectedDate.year, selectedDate.month]);
+  const calendarView = calendarService.generateMonthView(
+    currentMonth.year,
+    currentMonth.month,
+    selectedDate,
+    tasks
+  );
+  const isFocused = activePane === "calendar" && !isModalOpen;
+  const navigateDate = (newDate) => {
+    setSelectedDate({
+      year: newDate.getFullYear(),
+      month: newDate.getMonth(),
+      day: newDate.getDate()
+    });
+  };
+  useInput2(
+    (input, key) => {
+      if (!isFocused) return;
+      const currentDate = new Date(
+        selectedDate.year,
+        selectedDate.month,
+        selectedDate.day
+      );
+      if (input === "h" || key.leftArrow) {
+        navigateDate(subDays(currentDate, 1));
+        return;
+      }
+      if (input === "l" || key.rightArrow) {
+        navigateDate(addDays(currentDate, 1));
+        return;
+      }
+      if (input === "j" || key.downArrow) {
+        navigateDate(addWeeks(currentDate, 1));
+        return;
+      }
+      if (input === "k" || key.upArrow) {
+        navigateDate(subWeeks(currentDate, 1));
+        return;
+      }
+      if (input === "n") {
+        const next = calendarService.getNextMonth(
+          currentMonth.year,
+          currentMonth.month
+        );
+        setCurrentMonth(next);
+        setSelectedDate({
+          year: next.year,
+          month: next.month,
+          day: 1
+        });
+        return;
+      }
+      if (input === "p") {
+        const prev = calendarService.getPreviousMonth(
+          currentMonth.year,
+          currentMonth.month
+        );
+        setCurrentMonth(prev);
+        setSelectedDate({
+          year: prev.year,
+          month: prev.month,
+          day: 1
+        });
+        return;
+      }
+      if (input === "T") {
+        const today = /* @__PURE__ */ new Date();
+        setSelectedDate({
+          year: today.getFullYear(),
+          month: today.getMonth(),
+          day: today.getDate()
+        });
+        return;
+      }
+    },
+    { isActive: isFocused && !isInputMode }
+  );
+  const monthName = calendarService.getMonthName(currentMonth.month);
+  return /* @__PURE__ */ jsx9(
+    Pane,
+    {
+      title: `${monthName} ${currentMonth.year}`,
+      isFocused,
+      center: true,
+      children: /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", alignItems: "center", children: [
+        /* @__PURE__ */ jsx9(MonthView, { calendarView }),
+        /* @__PURE__ */ jsxs5(Box5, { marginTop: 1, flexDirection: "column", alignItems: "center", children: [
+          /* @__PURE__ */ jsx9(Text3, { color: theme.colors.keyboardHint, dimColor: true, children: "h/l: days j/k: weeks" }),
+          /* @__PURE__ */ jsx9(Text3, { color: theme.colors.keyboardHint, dimColor: true, children: "n/p: month T: today" })
+        ] })
+      ] })
+    }
+  );
+};
+
+// src/components/tasks/TasksPane.tsx
+import { useState as useState6, useEffect as useEffect7, useMemo, useRef as useRef3 } from "react";
+import { Box as Box7, Text as Text5, useInput as useInput3 } from "ink";
+import { TextInput } from "@inkjs/ui";
+
+// src/components/tasks/TaskHeader.tsx
+import { Box as Box6, Text as Text4 } from "ink";
+import { jsx as jsx10, jsxs as jsxs6 } from "react/jsx-runtime";
+var TaskHeader = ({
+  selectedDate,
+  completionPercentage
+}) => {
+  const { theme } = useTheme();
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", marginBottom: 1, children: [
+    /* @__PURE__ */ jsx10(Text4, { color: theme.colors.taskHeader, children: formatDate(selectedDate, "EEEE, MMMM d, yyyy") }),
+    /* @__PURE__ */ jsxs6(Text4, { color: theme.colors.taskHeader, children: [
+      completionPercentage,
+      "% completed"
+    ] })
+  ] });
+};
+
+// src/services/taskService.ts
+import { v4 as uuid } from "uuid";
+
+// src/utils/tree.ts
+var findTaskById = (tasks, id) => {
+  for (const task of tasks) {
+    if (task.id === id) return task;
+    const found = findTaskById(task.children, id);
+    if (found) return found;
+  }
+  return null;
+};
+var updateTaskInTree = (tasks, id, updates) => {
+  return tasks.map((task) => {
+    if (task.id === id) {
+      return { ...task, ...updates, updatedAt: /* @__PURE__ */ new Date() };
+    }
+    return {
+      ...task,
+      children: updateTaskInTree(task.children, id, updates)
+    };
+  });
+};
+var deleteTaskFromTree = (tasks, id) => {
+  return tasks.filter((task) => task.id !== id).map((task) => ({
+    ...task,
+    children: deleteTaskFromTree(task.children, id)
+  }));
+};
+var addSubtaskToTree = (tasks, parentId, newTask) => {
+  return tasks.map((task) => {
+    if (task.id === parentId) {
+      return {
+        ...task,
+        children: [...task.children, newTask]
+      };
+    }
+    return {
+      ...task,
+      children: addSubtaskToTree(task.children, parentId, newTask)
+    };
+  });
+};
+var flattenTasks = (tasks) => {
+  const result = [];
+  const traverse = (taskList) => {
+    for (const task of taskList) {
+      result.push(task);
+      traverse(task.children);
+    }
+  };
+  traverse(tasks);
+  return result;
+};
+var getTaskStats = (tasks) => {
+  const flat = flattenTasks(tasks);
+  const total = flat.length;
+  const completed = flat.filter((t) => t.state === "completed").length;
+  return {
+    total,
+    completed,
+    percentage: total === 0 ? 0 : Math.round(completed / total * 100)
+  };
+};
+
+// src/utils/validation.ts
+var validateTaskTimes = (task) => {
+  if (task.startTime && task.endTime) {
+    if (task.startTime >= task.endTime) {
+      return {
+        valid: false,
+        error: "Start time must be before end time"
+      };
+    }
+  }
+  if (task.startTime && !task.endTime) {
+    if (task.startTime > /* @__PURE__ */ new Date()) {
+      return {
+        valid: false,
+        error: "Start time cannot be in the future"
+      };
+    }
+  }
+  return { valid: true };
+};
+var validateTaskTitle = (title) => {
+  if (!title || title.trim().length === 0) {
+    return {
+      valid: false,
+      error: "Task title cannot be empty"
+    };
+  }
+  if (title.length > 255) {
+    return {
+      valid: false,
+      error: "Task title is too long (max 255 characters)"
+    };
+  }
+  return { valid: true };
+};
+
+// src/services/taskService.ts
+var TaskService = class {
+  createTask(title, date, state = "todo") {
+    const validation = validateTaskTitle(title);
+    if (!validation.valid) {
+      throw new Error(validation.error);
+    }
+    const now = /* @__PURE__ */ new Date();
+    return {
+      id: uuid(),
+      title,
+      state,
+      createdAt: now,
+      updatedAt: now,
+      children: [],
+      date
+    };
+  }
+  updateTask(tasks, taskId, updates) {
+    const dateStr = Object.keys(tasks).find(
+      (date) => findTaskById(tasks[date], taskId)
+    );
+    if (!dateStr) {
+      throw new Error("Task not found");
+    }
+    if (updates.title) {
+      const validation = validateTaskTitle(updates.title);
+      if (!validation.valid) {
+        throw new Error(validation.error);
+      }
+    }
+    if (updates.startTime || updates.endTime) {
+      const task = findTaskById(tasks[dateStr], taskId);
+      if (task) {
+        const updated = { ...task, ...updates };
+        const validation = validateTaskTimes(updated);
+        if (!validation.valid) {
+          throw new Error(validation.error);
+        }
+      }
+    }
+    return {
+      ...tasks,
+      [dateStr]: updateTaskInTree(tasks[dateStr], taskId, {
+        ...updates,
+        updatedAt: /* @__PURE__ */ new Date()
+      })
+    };
+  }
+  deleteTask(tasks, taskId) {
+    const dateStr = Object.keys(tasks).find(
+      (date) => findTaskById(tasks[date], taskId)
+    );
+    if (!dateStr) {
+      throw new Error("Task not found");
+    }
+    return {
+      ...tasks,
+      [dateStr]: deleteTaskFromTree(tasks[dateStr], taskId)
+    };
+  }
+  addSubtask(tasks, parentId, title) {
+    const parentTask = Object.values(tasks).flat().find((t) => findTaskById([t], parentId));
+    if (!parentTask) {
+      throw new Error("Parent task not found");
+    }
+    const newSubtask = this.createTask(title, parentTask.date);
+    const dateStr = Object.keys(tasks).find(
+      (date) => findTaskById(tasks[date], parentId)
+    );
+    if (!dateStr) {
+      throw new Error("Parent task not found");
+    }
+    return {
+      ...tasks,
+      [dateStr]: addSubtaskToTree(tasks[dateStr], parentId, {
+        ...newSubtask,
+        parentId
+      })
+    };
+  }
+  changeTaskState(tasks, taskId, newState) {
+    return this.updateTask(tasks, taskId, {
+      state: newState,
+      endTime: ["completed", "delegated", "delayed"].includes(newState) ? /* @__PURE__ */ new Date() : void 0
+    });
+  }
+  startTask(tasks, taskId, startTime) {
+    return this.updateTask(tasks, taskId, {
+      startTime: startTime || /* @__PURE__ */ new Date(),
+      endTime: void 0,
+      state: "todo"
+      // Reset to todo when starting
+    });
+  }
+  getTasksForDate(tasks, date) {
+    return tasks[date] || [];
+  }
+  getAllTasks(tasks) {
+    return Object.values(tasks).flat();
+  }
+  getTaskStats(tasks, date) {
+    return getTaskStats(this.getTasksForDate(tasks, date));
+  }
+};
+var taskService = new TaskService();
+
+// src/services/timelineService.ts
+import { v4 as uuid2 } from "uuid";
+var TimelineService = class {
+  createEvent(taskId, taskTitle, eventType, timestamp = /* @__PURE__ */ new Date(), previousState, newState) {
+    return {
+      id: uuid2(),
+      taskId,
+      taskTitle,
+      type: eventType,
+      timestamp,
+      previousState,
+      newState
+    };
+  }
+  getEventsForDate(timeline, date) {
+    return timeline[date] || [];
+  }
+  addEvent(timeline, event) {
+    const dateStr = getDateString(event.timestamp);
+    return {
+      ...timeline,
+      [dateStr]: [...timeline[dateStr] || [], event]
+    };
+  }
+  // Remove all events for a specific task (used when deleting a task)
+  removeEventsByTaskId(timeline, taskId) {
+    const result = {};
+    for (const [date, events] of Object.entries(timeline)) {
+      const filtered = events.filter((e) => e.taskId !== taskId);
+      if (filtered.length > 0) {
+        result[date] = filtered;
+      }
+    }
+    return result;
+  }
+  // Remove the last event of a specific type for a task (used for undo operations)
+  removeLastEventByType(timeline, taskId, eventType) {
+    const result = {};
+    let removed = false;
+    const dates = Object.keys(timeline).sort().reverse();
+    for (const date of dates) {
+      const events = timeline[date];
+      if (!removed) {
+        const lastIndex = events.map((e, i) => ({ e, i })).filter(({ e }) => e.taskId === taskId && e.type === eventType).pop()?.i;
+        if (lastIndex !== void 0) {
+          const filtered = events.filter((_, i) => i !== lastIndex);
+          if (filtered.length > 0) {
+            result[date] = filtered;
+          }
+          removed = true;
+        } else {
+          result[date] = events;
+        }
+      } else {
+        result[date] = events;
+      }
+    }
+    return result;
+  }
+  formatEventDescription(event) {
+    const timeStr = event.timestamp.toLocaleTimeString("en-US", {
+      hour: "2-digit",
+      minute: "2-digit",
+      hour12: true
+    });
+    const stateInfo = event.newState ? ` (${event.previousState} -> ${event.newState})` : "";
+    return `${timeStr} - ${event.type.charAt(0).toUpperCase() + event.type.slice(1)}: ${event.taskTitle}${stateInfo}`;
+  }
+};
+var timelineService = new TimelineService();
+
+// src/components/tasks/TasksPane.tsx
+import { Fragment, jsx as jsx11, jsxs as jsxs7 } from "react/jsx-runtime";
+var TasksPane = () => {
+  const {
+    tasks,
+    setTasks,
+    timeline,
+    setTimeline,
+    activePane,
+    selectedDate,
+    isInputMode,
+    setIsInputMode,
+    isModalOpen
+  } = useApp();
+  const { theme } = useTheme();
+  const [expandedIds, setExpandedIds] = useState6(/* @__PURE__ */ new Set());
+  const [selectedIndex, setSelectedIndex] = useState6(0);
+  const [editMode, setEditMode] = useState6("none");
+  const [editValue, setEditValue] = useState6("");
+  const [parentTaskId, setParentTaskId] = useState6(null);
+  const inputValueRef = useRef3("");
+  const [inputKey, setInputKey] = useState6(0);
+  const [scrollOffset, setScrollOffset] = useState6(0);
+  const { height: terminalHeight } = useTerminalSize();
+  const visibleRows = useMemo(() => {
+    return Math.max(5, terminalHeight - 11);
+  }, [terminalHeight]);
+  const dateStr = getDateString(
+    new Date(selectedDate.year, selectedDate.month, selectedDate.day)
+  );
+  const dayTasks = tasks[dateStr] || [];
+  const stats = taskService.getTaskStats(tasks, dateStr);
+  const isFocused = activePane === "tasks" && !isModalOpen;
+  const flatTasks = useMemo(() => {
+    const result = [];
+    const traverse = (taskList, depth) => {
+      for (const task of taskList) {
+        result.push({ task, depth });
+        if (task.children.length > 0 && expandedIds.has(task.id)) {
+          traverse(task.children, depth + 1);
+        }
+      }
+    };
+    traverse(dayTasks, 0);
+    return result;
+  }, [dayTasks, expandedIds]);
+  const selectedTask = flatTasks[selectedIndex]?.task;
+  const selectedTaskId = selectedTask?.id;
+  useEffect7(() => {
+    setSelectedIndex(0);
+    setEditMode("none");
+  }, [dateStr]);
+  useEffect7(() => {
+    if (selectedIndex >= flatTasks.length && flatTasks.length > 0) {
+      setSelectedIndex(flatTasks.length - 1);
+    }
+  }, [flatTasks.length, selectedIndex]);
+  useEffect7(() => {
+    if (selectedIndex < scrollOffset) {
+      setScrollOffset(selectedIndex);
+    } else if (selectedIndex >= scrollOffset + visibleRows) {
+      setScrollOffset(selectedIndex - visibleRows + 1);
+    }
+  }, [selectedIndex, visibleRows, scrollOffset]);
+  useEffect7(() => {
+    setScrollOffset(0);
+  }, [dateStr]);
+  const handleAddTask = () => {
+    inputValueRef.current = "";
+    setEditMode("add");
+    setEditValue("");
+    setInputKey((k) => k + 1);
+    setIsInputMode(true);
+  };
+  const handleEditTask = () => {
+    if (selectedTask) {
+      inputValueRef.current = selectedTask.title;
+      setEditMode("edit");
+      setEditValue(selectedTask.title);
+      setInputKey((k) => k + 1);
+      setIsInputMode(true);
+    }
+  };
+  const handleAddSubtask = () => {
+    if (selectedTask) {
+      inputValueRef.current = "";
+      setEditMode("addSubtask");
+      setEditValue("");
+      setParentTaskId(selectedTask.id);
+      setInputKey((k) => k + 1);
+      setIsInputMode(true);
+      setExpandedIds((prev) => new Set(prev).add(selectedTask.id));
+    }
+  };
+  const handleDeleteTask = () => {
+    if (selectedTaskId) {
+      try {
+        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 {
+        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(
+            timeline,
+            selectedTaskId,
+            eventTypeToRemove[previousState]
+          );
+          setTimeline(updatedTimeline);
+        } else {
+          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 changing task state:", err);
+      }
+    }
+  };
+  const handleToggleComplete = () => {
+    if (selectedTask) {
+      const newState = selectedTask.state === "completed" ? "todo" : "completed";
+      handleChangeState(newState);
+    }
+  };
+  const handleSubmitEdit = (value) => {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      setEditMode("none");
+      setEditValue("");
+      setParentTaskId(null);
+      setIsInputMode(false);
+      return;
+    }
+    try {
+      if (editMode === "add") {
+        const newTask = taskService.createTask(trimmed, dateStr);
+        const newTasks = {
+          ...tasks,
+          [dateStr]: [...dayTasks, newTask]
+        };
+        setTasks(newTasks);
+        setSelectedIndex(flatTasks.length);
+      } else if (editMode === "addSubtask" && parentTaskId) {
+        const updated = taskService.addSubtask(tasks, parentTaskId, trimmed);
+        setTasks(updated);
+        const parentIndex = flatTasks.findIndex(
+          (ft) => ft.task.id === parentTaskId
+        );
+        if (parentIndex !== -1) {
+          setSelectedIndex(parentIndex + 1);
+        }
+      } else if (editMode === "edit" && selectedTaskId) {
+        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);
+    setIsInputMode(false);
+  };
+  const handleToggleExpand = () => {
+    if (selectedTaskId && selectedTask?.children.length > 0) {
+      setExpandedIds((prev) => {
+        const newSet = new Set(prev);
+        if (newSet.has(selectedTaskId)) {
+          newSet.delete(selectedTaskId);
+        } else {
+          newSet.add(selectedTaskId);
+        }
+        return newSet;
+      });
+    }
+  };
+  const handleExpand = () => {
+    if (selectedTaskId && selectedTask?.children.length > 0) {
+      setExpandedIds((prev) => new Set(prev).add(selectedTaskId));
+    }
+  };
+  const handleCollapse = () => {
+    if (selectedTaskId && selectedTask?.children.length > 0) {
+      setExpandedIds((prev) => {
+        const newSet = new Set(prev);
+        newSet.delete(selectedTaskId);
+        return newSet;
+      });
+    }
+  };
+  const handleExpandAll = () => {
+    const allParentIds = /* @__PURE__ */ new Set();
+    const collectParents = (taskList) => {
+      for (const task of taskList) {
+        if (task.children.length > 0) {
+          allParentIds.add(task.id);
+          collectParents(task.children);
+        }
+      }
+    };
+    collectParents(dayTasks);
+    setExpandedIds(allParentIds);
+  };
+  const handleCollapseAll = () => {
+    setExpandedIds(/* @__PURE__ */ new Set());
+  };
+  useInput3(
+    (_input, key) => {
+      if (key.escape) {
+        handleCancelEdit();
+      }
+    },
+    { isActive: isFocused && editMode !== "none" }
+  );
+  useInput3(
+    (input, key) => {
+      if ((key.meta || key.ctrl) && (input === "a" || key.leftArrow)) {
+        handleCollapseAll();
+        return;
+      }
+      if ((key.meta || key.ctrl) && (input === "e" || key.rightArrow)) {
+        handleExpandAll();
+        return;
+      }
+      if (input === "j" || key.downArrow) {
+        setSelectedIndex((prev) => Math.min(prev + 1, flatTasks.length - 1));
+        return;
+      }
+      if (input === "k" || key.upArrow) {
+        setSelectedIndex((prev) => Math.max(prev - 1, 0));
+        return;
+      }
+      if (key.leftArrow && !key.meta && !key.ctrl) {
+        handleCollapse();
+        return;
+      }
+      if (key.rightArrow && !key.meta && !key.ctrl) {
+        handleExpand();
+        return;
+      }
+      if (input === "a" && !key.meta && !key.ctrl && !key.shift) {
+        handleAddTask();
+        return;
+      }
+      if (input === "e" && selectedTask && !key.meta && !key.ctrl && !key.shift) {
+        handleEditTask();
+        return;
+      }
+      if (input === "d" && selectedTask) {
+        handleDeleteTask();
+        return;
+      }
+      if (input === " " && selectedTask) {
+        handleToggleComplete();
+        return;
+      }
+      if (input === "D" && selectedTask) {
+        handleChangeState("delegated");
+        return;
+      }
+      if (input === "x" && selectedTask) {
+        if (selectedTask.state === "delayed") {
+          handleChangeState("todo");
+        } else {
+          handleChangeState("delayed");
+        }
+        return;
+      }
+      if (input === "s" && selectedTask) {
+        try {
+          if (selectedTask.startTime && !selectedTask.endTime) {
+            const updated = taskService.updateTask(tasks, selectedTaskId, {
+              startTime: void 0
+            });
+            setTasks(updated);
+            const updatedTimeline = timelineService.removeLastEventByType(
+              timeline,
+              selectedTaskId,
+              "started" /* STARTED */
+            );
+            setTimeline(updatedTimeline);
+          } else {
+            const updated = taskService.startTask(tasks, selectedTaskId);
+            setTasks(updated);
+            const event = timelineService.createEvent(
+              selectedTaskId,
+              selectedTask.title,
+              "started" /* STARTED */,
+              /* @__PURE__ */ new Date()
+            );
+            const updatedTimeline = timelineService.addEvent(timeline, event);
+            setTimeline(updatedTimeline);
+          }
+        } catch (err) {
+          console.error("Error toggling task start:", err);
+        }
+        return;
+      }
+      if (key.return && selectedTask) {
+        handleToggleExpand();
+        return;
+      }
+      if (key.tab && selectedTask) {
+        handleAddSubtask();
+        return;
+      }
+    },
+    { isActive: isFocused && editMode === "none" }
+  );
+  return /* @__PURE__ */ jsx11(Pane, { title: "Tasks", isFocused, children: /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", flexGrow: 1, children: [
+    /* @__PURE__ */ jsx11(
+      TaskHeader,
+      {
+        selectedDate: new Date(selectedDate.year, selectedDate.month, selectedDate.day),
+        completionPercentage: stats.percentage
+      }
+    ),
+    editMode === "add" && /* @__PURE__ */ jsxs7(Box7, { marginY: 1, children: [
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.focusIndicator, children: ">  " }),
+      /* @__PURE__ */ jsx11(
+        TextInput,
+        {
+          defaultValue: "",
+          placeholder: "Enter task name...",
+          onChange: (val) => {
+            inputValueRef.current = val;
+          },
+          onSubmit: handleSubmitEdit
+        },
+        `add-${inputKey}`
+      )
+    ] }),
+    editMode === "addSubtask" && /* @__PURE__ */ jsxs7(Box7, { marginY: 1, children: [
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.focusIndicator, children: ">  " }),
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, children: "  " }),
+      /* @__PURE__ */ jsx11(
+        TextInput,
+        {
+          defaultValue: "",
+          placeholder: "Enter subtask name...",
+          onChange: (val) => {
+            inputValueRef.current = val;
+          },
+          onSubmit: handleSubmitEdit
+        },
+        `subtask-${inputKey}`
+      )
+    ] }),
+    dayTasks.length === 0 && editMode !== "add" && editMode !== "addSubtask" ? /* @__PURE__ */ jsx11(Box7, { marginY: 1, children: /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "No tasks. Press 'a' to add one." }) }) : /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", marginY: 1, paddingRight: 2, children: [
+      scrollOffset > 0 && /* @__PURE__ */ jsx11(Box7, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) }),
+      flatTasks.slice(scrollOffset, scrollOffset + visibleRows).map(({ task, depth }, sliceIndex) => {
+        const index = scrollOffset + sliceIndex;
+        const isSelected = index === selectedIndex;
+        const isExpanded = expandedIds.has(task.id);
+        const isEditing = editMode === "edit" && isSelected;
+        if (isEditing) {
+          return /* @__PURE__ */ jsxs7(Box7, { children: [
+            /* @__PURE__ */ jsx11(Text5, { color: theme.colors.focusIndicator, children: ">  " }),
+            /* @__PURE__ */ jsx11(
+              TextInput,
+              {
+                defaultValue: editValue,
+                onChange: (val) => {
+                  inputValueRef.current = val;
+                },
+                onSubmit: handleSubmitEdit
+              },
+              `edit-${inputKey}`
+            )
+          ] }, task.id);
+        }
+        return /* @__PURE__ */ jsxs7(Box7, { children: [
+          /* @__PURE__ */ jsx11(
+            Text5,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
+              children: isSelected ? ">" : " "
+            }
+          ),
+          /* @__PURE__ */ jsx11(Text5, { children: " " }),
+          /* @__PURE__ */ jsx11(Text5, { children: "  ".repeat(depth) }),
+          /* @__PURE__ */ jsx11(
+            Text5,
+            {
+              color: isSelected ? theme.colors.focusIndicator : getStateColor(task.state, theme),
+              children: getCheckbox(task.state)
+            }
+          ),
+          /* @__PURE__ */ jsx11(Text5, { children: " " }),
+          task.children.length > 0 && /* @__PURE__ */ jsxs7(Fragment, { children: [
+            /* @__PURE__ */ jsx11(Text5, { children: isExpanded ? "\u25BC" : "\u25B6" }),
+            /* @__PURE__ */ jsx11(Text5, { children: " " })
+          ] }),
+          /* @__PURE__ */ jsx11(
+            Text5,
+            {
+              color: isSelected ? theme.colors.focusIndicator : getStateColor(task.state, theme),
+              strikethrough: task.state === "completed",
+              dimColor: task.state === "delayed" && !isSelected,
+              children: task.title
+            }
+          ),
+          task.startTime && !task.endTime && /* @__PURE__ */ jsxs7(
+            Text5,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.timelineEventStarted,
+              children: [
+                " ",
+                "\u25B6"
+              ]
+            }
+          )
+        ] }, task.id);
+      }),
+      scrollOffset + visibleRows < flatTasks.length && /* @__PURE__ */ jsx11(Box7, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) })
+    ] }),
+    /* @__PURE__ */ jsxs7(Box7, { marginTop: 1, flexDirection: "column", children: [
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "j/k: navigate a: add Tab: add subtask e: edit d: delete" }),
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "Space: complete D: delegate x: delay s: start" }),
+      /* @__PURE__ */ jsx11(Text5, { color: theme.colors.keyboardHint, dimColor: true, children: "\u2190/\u2192: collapse/expand Cmd+\u2190/\u2192: collapse/expand all" })
+    ] })
+  ] }) });
+};
+function getCheckbox(state) {
+  switch (state) {
+    case "completed":
+      return "[\u2713]";
+    case "delegated":
+      return "[\u2192]";
+    case "delayed":
+      return "[\u2016]";
+    default:
+      return "[ ]";
+  }
+}
+function getStateColor(state, theme) {
+  const colors = {
+    todo: theme.colors.taskStateTodo,
+    completed: theme.colors.taskStateCompleted,
+    delegated: theme.colors.taskStateDelegated,
+    delayed: theme.colors.taskStateDelayed
+  };
+  return colors[state] || theme.colors.foreground;
+}
+
+// src/components/timeline/TimelinePane.tsx
+import { useState as useState7, useEffect as useEffect8, useMemo as useMemo2 } from "react";
+import { Box as Box9, Text as Text7, useInput as useInput4 } from "ink";
+
+// src/components/timeline/TimelineEntry.tsx
+import { Box as Box8, Text as Text6 } from "ink";
+import { jsx as jsx12, jsxs as jsxs8 } from "react/jsx-runtime";
+var TimelineEntry = ({
+  event,
+  isLast,
+  hasNextSameTask
+}) => {
+  const { theme } = useTheme();
+  const hours = event.timestamp.getHours();
+  const minutes = event.timestamp.getMinutes();
+  const ampm = hours >= 12 ? "pm" : "am";
+  const hour12 = hours % 12 || 12;
+  const timeStr = `${hour12}:${minutes.toString().padStart(2, "0")} ${ampm}`;
+  const typeStr = event.type.charAt(0).toUpperCase() + event.type.slice(1);
+  const eventTypeColors = {
+    created: theme.colors.foreground,
+    started: theme.colors.foreground,
+    completed: theme.colors.taskStateCompleted,
+    delegated: theme.colors.taskStateDelegated,
+    delayed: theme.colors.taskStateDelayed,
+    updated: theme.colors.foreground
+  };
+  const color = eventTypeColors[event.type] || theme.colors.foreground;
+  const isFilledCircle = ["completed", "delegated", "delayed"].includes(
+    event.type
+  );
+  return /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsxs8(Box8, { children: [
+      /* @__PURE__ */ jsx12(Box8, { width: 3, justifyContent: "center", children: /* @__PURE__ */ jsx12(Text6, { color, children: isFilledCircle ? "\u25CF" : "\u25CB" }) }),
+      /* @__PURE__ */ jsxs8(Box8, { flexDirection: "column", flexGrow: 1, children: [
+        /* @__PURE__ */ jsx12(Box8, { children: /* @__PURE__ */ jsxs8(Text6, { children: [
+          /* @__PURE__ */ jsxs8(Text6, { color, bold: true, children: [
+            typeStr,
+            ":"
+          ] }),
+          /* @__PURE__ */ jsxs8(Text6, { color: theme.colors.foreground, children: [
+            " ",
+            event.taskTitle
+          ] })
+        ] }) }),
+        /* @__PURE__ */ jsx12(Box8, { children: /* @__PURE__ */ jsx12(Text6, { color: theme.colors.keyboardHint, dimColor: true, children: timeStr }) })
+      ] })
+    ] }),
+    !isLast && /* @__PURE__ */ jsx12(Box8, { children: /* @__PURE__ */ jsx12(Box8, { width: 3, justifyContent: "center", children: /* @__PURE__ */ jsx12(Text6, { color: hasNextSameTask ? color : theme.colors.border, children: "\u2502" }) }) })
+  ] });
+};
+
+// src/components/timeline/TimelinePane.tsx
+import { jsx as jsx13, jsxs as jsxs9 } from "react/jsx-runtime";
+var TimelinePane = () => {
+  const { theme } = useTheme();
+  const { selectedDate, timeline, activePane, isModalOpen, isInputMode } = useApp();
+  const isFocused = activePane === "timeline" && !isModalOpen;
+  const [scrollOffset, setScrollOffset] = useState7(0);
+  const { height: terminalHeight } = useTerminalSize();
+  const visibleRows = useMemo2(() => {
+    return Math.max(5, terminalHeight - 10);
+  }, [terminalHeight]);
+  const dateStr = getDateString(
+    new Date(selectedDate.year, selectedDate.month, selectedDate.day)
+  );
+  const dayEvents = timeline[dateStr] || [];
+  const sortedEvents = useMemo2(() => {
+    const eventsByTask = /* @__PURE__ */ new Map();
+    dayEvents.forEach((event) => {
+      const taskEvents = eventsByTask.get(event.taskId) || [];
+      taskEvents.push(event);
+      eventsByTask.set(event.taskId, taskEvents);
+    });
+    eventsByTask.forEach((events) => {
+      events.sort((a, b) => a.timestamp.getTime() - b.timestamp.getTime());
+    });
+    const taskGroups = Array.from(eventsByTask.entries()).sort(
+      ([, eventsA], [, eventsB]) => {
+        const earliestA = eventsA[0]?.timestamp.getTime() || 0;
+        const earliestB = eventsB[0]?.timestamp.getTime() || 0;
+        return earliestA - earliestB;
+      }
+    );
+    return taskGroups.flatMap(([, events]) => events);
+  }, [dayEvents]);
+  useEffect8(() => {
+    setScrollOffset(0);
+  }, [dateStr]);
+  useInput4(
+    (input, key) => {
+      if (!isFocused) return;
+      if (input === "j" || key.downArrow) {
+        setScrollOffset(
+          (prev) => Math.min(prev + 1, Math.max(0, sortedEvents.length - visibleRows))
+        );
+      }
+      if (input === "k" || key.upArrow) {
+        setScrollOffset((prev) => Math.max(prev - 1, 0));
+      }
+      if (input === "d" && key.ctrl) {
+        setScrollOffset(
+          (prev) => Math.min(
+            prev + Math.floor(visibleRows / 2),
+            Math.max(0, sortedEvents.length - visibleRows)
+          )
+        );
+      }
+      if (input === "u" && key.ctrl) {
+        setScrollOffset(
+          (prev) => Math.max(prev - Math.floor(visibleRows / 2), 0)
+        );
+      }
+    },
+    { isActive: isFocused && !isInputMode }
+  );
+  const visibleEvents = sortedEvents.slice(
+    scrollOffset,
+    scrollOffset + visibleRows
+  );
+  const canScrollUp = scrollOffset > 0;
+  const canScrollDown = scrollOffset + visibleRows < sortedEvents.length;
+  return /* @__PURE__ */ jsx13(Pane, { title: "Timeline", isFocused, children: /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", flexGrow: 1, children: [
+    sortedEvents.length === 0 ? /* @__PURE__ */ jsxs9(Box9, { marginY: 1, flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx13(Text7, { color: theme.colors.keyboardHint, dimColor: true, children: "No activities yet." }),
+      /* @__PURE__ */ jsx13(Text7, { color: theme.colors.keyboardHint, dimColor: true, children: "Press 's' to start a task." })
+    ] }) : /* @__PURE__ */ jsxs9(Box9, { flexDirection: "column", children: [
+      canScrollUp && /* @__PURE__ */ jsx13(Box9, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx13(Text7, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) }),
+      /* @__PURE__ */ jsx13(Box9, { flexDirection: "column", children: visibleEvents.map((event, index) => {
+        const globalIndex = scrollOffset + index;
+        const isLast = globalIndex === sortedEvents.length - 1;
+        const nextEvent = sortedEvents[globalIndex + 1];
+        const hasNextSameTask = nextEvent && nextEvent.taskId === event.taskId;
+        return /* @__PURE__ */ jsx13(
+          TimelineEntry,
+          {
+            event,
+            isLast,
+            hasNextSameTask
+          },
+          event.id
+        );
+      }) }),
+      canScrollDown && /* @__PURE__ */ jsx13(Box9, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx13(Text7, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) })
+    ] }),
+    /* @__PURE__ */ jsx13(Box9, { marginTop: 1, children: /* @__PURE__ */ jsx13(Text7, { color: theme.colors.keyboardHint, dimColor: true, children: "j/k: scroll" }) })
+  ] }) });
+};
+
+// src/components/common/HelpDialog.tsx
+import { Box as Box12, Text as Text8 } from "ink";
+
+// src/components/common/Modal.tsx
+import { Box as Box11, useStdout as useStdout3 } from "ink";
+
+// src/components/common/FullscreenBackground.tsx
+import { Box as Box10, useStdout as useStdout2 } from "ink";
+import { jsx as jsx14 } from "react/jsx-runtime";
+var FullscreenBackground = ({
+  children,
+  backgroundColor
+}) => {
+  const { stdout } = useStdout2();
+  const width = stdout?.columns || 100;
+  const height = stdout?.rows || 30;
+  return /* @__PURE__ */ jsx14(
+    Box10,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      backgroundColor,
+      children
+    }
+  );
+};
+
+// src/components/common/Modal.tsx
+import { jsx as jsx15 } from "react/jsx-runtime";
+var Modal = ({ children }) => {
+  const { theme } = useTheme();
+  const { stdout } = useStdout3();
+  const width = stdout?.columns || 100;
+  const height = stdout?.rows || 30;
+  return /* @__PURE__ */ jsx15(
+    FullscreenBackground,
+    {
+      backgroundColor: theme.colors.modalOverlay || "black",
+      children: /* @__PURE__ */ jsx15(
+        Box11,
+        {
+          flexDirection: "column",
+          width,
+          height,
+          justifyContent: "center",
+          alignItems: "center",
+          children
+        }
+      )
+    }
+  );
+};
+
+// src/components/common/HelpDialog.tsx
+import { Fragment as Fragment2, jsx as jsx16, jsxs as jsxs10 } from "react/jsx-runtime";
+var HelpDialog = () => {
+  const { theme } = useTheme();
+  const shortcuts = [
+    { key: "Ctrl+C (twice)", action: "Quit application" },
+    { key: "?", action: "Toggle help dialog" },
+    { key: "Shift+;", action: "Show month overview" },
+    { key: "t", action: "Select theme" },
+    { key: "1", action: "Focus calendar pane" },
+    { key: "2 / Tab", action: "Focus tasks pane" },
+    { key: "3 / Shift+Tab", action: "Focus timeline pane" },
+    { key: "", action: "" },
+    { key: "Calendar Pane", action: "" },
+    { key: "h/l \u2190/\u2192", action: "Navigate days" },
+    { key: "j/k \u2193/\u2191", action: "Navigate weeks" },
+    { key: "n/p", action: "Next/prev month" },
+    { key: "T", action: "Go to today" },
+    { key: "", action: "" },
+    { key: "Tasks Pane", action: "" },
+    { key: "j/k \u2193/\u2191", action: "Navigate tasks" },
+    { key: "a", action: "Add new task" },
+    { key: "e", action: "Edit task" },
+    { key: "d", action: "Delete task" },
+    { key: "Space", action: "Toggle completion" },
+    { key: "s", action: "Start task" },
+    { key: "D", action: "Mark delegated" },
+    { key: "x", action: "Mark delayed/cancelled" },
+    { key: "Enter", action: "Expand/collapse subtasks" },
+    { key: "", action: "" },
+    { key: "Timeline Pane", action: "" },
+    { key: "j/k", action: "Scroll timeline" },
+    { key: "Shift+C", action: "Clear timeline" }
+  ];
+  return /* @__PURE__ */ jsx16(Modal, { children: /* @__PURE__ */ jsxs10(
+    Box12,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.helpDialogBorder,
+      paddingX: 2,
+      paddingY: 1,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx16(Text8, { bold: true, color: theme.colors.calendarHeader, children: "Keyboard Shortcuts" }),
+        /* @__PURE__ */ jsx16(Box12, { flexDirection: "column", marginTop: 1, children: shortcuts.map((item, idx) => /* @__PURE__ */ jsx16(Box12, { marginY: 0, children: item.key ? /* @__PURE__ */ jsxs10(Fragment2, { children: [
+          /* @__PURE__ */ jsx16(Box12, { width: 20, children: /* @__PURE__ */ jsx16(Text8, { color: theme.colors.timelineEventStarted, children: item.key }) }),
+          /* @__PURE__ */ jsx16(Text8, { color: theme.colors.foreground, children: item.action })
+        ] }) : /* @__PURE__ */ jsx16(Text8, { 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__ */ jsx16(Box12, { marginY: 1, children: /* @__PURE__ */ jsx16(Text8, { color: theme.colors.keyboardHint, dimColor: true, children: "Press '?' to close" }) })
+      ]
+    }
+  ) });
+};
+
+// src/components/common/ThemeDialog.tsx
+import { useState as useState8, useMemo as useMemo3, useEffect as useEffect9 } from "react";
+import { Box as Box13, Text as Text9, useInput as useInput5 } from "ink";
+import TextInput2 from "ink-text-input";
+import { jsx as jsx17, jsxs as jsxs11 } from "react/jsx-runtime";
+var ThemeDialog = () => {
+  const { theme, setTheme, themeName } = useTheme();
+  const { setShowThemeDialog } = useApp();
+  const [searchQuery, setSearchQuery] = useState8("");
+  const [focusMode, setFocusMode] = useState8("search");
+  const lightThemes2 = useMemo3(() => getLightThemeNames(), []);
+  const darkThemes2 = useMemo3(() => getDarkThemeNames(), []);
+  const allThemes = useMemo3(() => {
+    const query = searchQuery.toLowerCase();
+    const filteredLightThemes = lightThemes2.filter(
+      (t) => t.toLowerCase().includes(query)
+    );
+    const filteredDarkThemes = darkThemes2.filter(
+      (t) => t.toLowerCase().includes(query)
+    );
+    const items = [];
+    if (filteredLightThemes.length > 0) {
+      items.push({ type: "separator", value: "Light Themes" });
+      filteredLightThemes.forEach(
+        (t) => items.push({ type: "theme", value: t })
+      );
+    }
+    if (filteredDarkThemes.length > 0) {
+      items.push({ type: "separator", value: "Dark Themes" });
+      filteredDarkThemes.forEach(
+        (t) => items.push({ type: "theme", value: t })
+      );
+    }
+    return items;
+  }, [lightThemes2, darkThemes2, searchQuery]);
+  const themeItems = useMemo3(
+    () => allThemes.filter((item) => item.type === "theme"),
+    [allThemes]
+  );
+  const initialIndex = useMemo3(() => {
+    const idx = themeItems.findIndex((item) => item.value === themeName);
+    return idx >= 0 ? idx : 0;
+  }, [themeItems, themeName]);
+  const [selectedIndex, setSelectedIndex] = useState8(initialIndex);
+  useEffect9(() => {
+    setSelectedIndex(0);
+  }, [searchQuery]);
+  useInput5(
+    (input, key) => {
+      if (key.escape) {
+        setShowThemeDialog(false);
+        return;
+      }
+      if (focusMode === "search") {
+        if (key.return && themeItems.length > 0) {
+          setTheme(themeItems[0].value);
+          setShowThemeDialog(false);
+          return;
+        }
+        if (key.downArrow && themeItems.length > 0) {
+          setFocusMode("list");
+          setSelectedIndex(0);
+          return;
+        }
+      } else {
+        if (key.upArrow || input === "k") {
+          if (selectedIndex > 0) {
+            setSelectedIndex((prev) => prev - 1);
+          } else {
+            setFocusMode("search");
+          }
+          return;
+        }
+        if (key.downArrow || input === "j") {
+          setSelectedIndex(
+            (prev) => prev < themeItems.length - 1 ? prev + 1 : 0
+          );
+          return;
+        }
+        if (key.return && themeItems.length > 0) {
+          setTheme(themeItems[selectedIndex].value);
+          setShowThemeDialog(false);
+          return;
+        }
+      }
+    },
+    { isActive: true }
+  );
+  const selectedThemeName = themeItems[selectedIndex]?.value;
+  const formatThemeName = (name) => {
+    return name.split("-").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+  };
+  return /* @__PURE__ */ jsx17(Modal, { children: /* @__PURE__ */ jsxs11(
+    Box13,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.helpDialogBorder,
+      paddingX: 2,
+      paddingY: 1,
+      width: 44,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx17(Text9, { bold: true, color: theme.colors.calendarHeader, underline: true, children: "Select Theme" }),
+        /* @__PURE__ */ jsxs11(Box13, { marginTop: 1, flexDirection: "row", alignItems: "center", children: [
+          /* @__PURE__ */ jsxs11(Text9, { color: theme.colors.foreground, dimColor: true, children: [
+            "Search:",
+            " "
+          ] }),
+          /* @__PURE__ */ jsx17(Text9, { color: theme.colors.foreground, children: /* @__PURE__ */ jsx17(
+            TextInput2,
+            {
+              value: searchQuery,
+              onChange: setSearchQuery,
+              focus: focusMode === "search",
+              placeholder: "Type to filter..."
+            }
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx17(Box13, { flexDirection: "column", marginTop: 1, children: allThemes.map((item, idx) => {
+          if (item.type === "separator") {
+            return /* @__PURE__ */ jsx17(
+              Box13,
+              {
+                marginTop: idx > 0 ? 1 : 0,
+                marginBottom: 0,
+                children: /* @__PURE__ */ jsx17(Text9, { bold: true, color: theme.colors.calendarHeader, dimColor: true, children: item.value })
+              },
+              `sep-${idx}`
+            );
+          }
+          const isSelected = item.value === selectedThemeName;
+          const isCurrent = item.value === themeName;
+          return /* @__PURE__ */ jsx17(Box13, { paddingLeft: 1, children: /* @__PURE__ */ jsxs11(
+            Text9,
+            {
+              color: isSelected ? theme.colors.focusIndicator : theme.colors.foreground,
+              bold: isSelected,
+              children: [
+                isSelected ? "\u279C " : "  ",
+                formatThemeName(item.value),
+                isCurrent ? " (current)" : ""
+              ]
+            }
+          ) }, item.value);
+        }) }),
+        /* @__PURE__ */ jsx17(Box13, { marginTop: 1, children: /* @__PURE__ */ jsx17(Text9, { color: theme.colors.keyboardHint, dimColor: true, children: focusMode === "search" ? "Type to search \u2022 \u2193 to navigate list \u2022 Esc to close" : "\u2191/\u2193 or k/j to navigate \u2022 Enter to select \u2022 Esc to close" }) })
+      ]
+    }
+  ) });
+};
+
+// src/components/common/ClearTimelineDialog.tsx
+import { Box as Box14, Text as Text10, useInput as useInput6 } from "ink";
+import { format as format2 } from "date-fns";
+import { jsx as jsx18, jsxs as jsxs12 } from "react/jsx-runtime";
+var ClearTimelineDialog = () => {
+  const { theme } = useTheme();
+  const {
+    selectedDate,
+    timeline,
+    setShowClearTimelineDialog,
+    clearTimelineForDate
+  } = useApp();
+  const date = new Date(selectedDate.year, selectedDate.month, selectedDate.day);
+  const dateStr = getDateString(date);
+  const formattedDate = format2(date, "MMMM do, yyyy");
+  const eventCount = (timeline[dateStr] || []).length;
+  const handleConfirm = () => {
+    clearTimelineForDate(dateStr);
+    setShowClearTimelineDialog(false);
+  };
+  const handleCancel = () => {
+    setShowClearTimelineDialog(false);
+  };
+  useInput6((input, key) => {
+    if (input.toLowerCase() === "y" || key.return) {
+      handleConfirm();
+    } else if (input.toLowerCase() === "n" || key.escape) {
+      handleCancel();
+    }
+  });
+  return /* @__PURE__ */ jsx18(Modal, { children: /* @__PURE__ */ jsxs12(
+    Box14,
+    {
+      flexDirection: "column",
+      borderStyle: "double",
+      borderColor: theme.colors.taskStateDelayed,
+      paddingX: 4,
+      paddingY: 2,
+      backgroundColor: theme.colors.modalBackground || theme.colors.background,
+      children: [
+        /* @__PURE__ */ jsx18(Box14, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx18(Text10, { bold: true, color: theme.colors.taskStateDelayed, children: "Clear Timeline" }) }),
+        /* @__PURE__ */ jsxs12(Box14, { flexDirection: "column", marginY: 1, children: [
+          /* @__PURE__ */ jsx18(Text10, { color: theme.colors.foreground, children: "You are about to clear the timeline for" }),
+          /* @__PURE__ */ jsx18(Box14, { justifyContent: "center", marginY: 1, children: /* @__PURE__ */ jsx18(Text10, { bold: true, color: theme.colors.calendarHeader, children: formattedDate }) }),
+          eventCount > 0 ? /* @__PURE__ */ jsxs12(Text10, { color: theme.colors.keyboardHint, children: [
+            "This will remove ",
+            eventCount,
+            " event",
+            eventCount !== 1 ? "s" : "",
+            " from the timeline."
+          ] }) : /* @__PURE__ */ jsx18(Text10, { color: theme.colors.keyboardHint, dimColor: true, children: "The timeline is already empty." })
+        ] }),
+        /* @__PURE__ */ jsxs12(Box14, { marginTop: 2, justifyContent: "center", children: [
+          /* @__PURE__ */ jsx18(Text10, { color: theme.colors.foreground, children: "Are you sure? " }),
+          /* @__PURE__ */ jsx18(Text10, { color: theme.colors.taskStateCompleted, bold: true, children: "[Y]es" }),
+          /* @__PURE__ */ jsx18(Text10, { color: theme.colors.foreground, children: " / " }),
+          /* @__PURE__ */ jsx18(Text10, { color: theme.colors.taskStateDelayed, bold: true, children: "[N]o" })
+        ] }),
+        /* @__PURE__ */ jsx18(Box14, { marginTop: 2, justifyContent: "center", children: /* @__PURE__ */ jsx18(Text10, { color: theme.colors.keyboardHint, dimColor: true, children: "Press Y to confirm, N or Esc to cancel" }) })
+      ]
+    }
+  ) });
+};
+
+// src/components/overview/OverviewScreen.tsx
+import React8, { useMemo as useMemo4 } from "react";
+import { Box as Box15, Text as Text11, useInput as useInput7 } from "ink";
+import { startOfMonth as startOfMonth2, endOfMonth as endOfMonth2, eachDayOfInterval as eachDayOfInterval2 } from "date-fns";
+import { jsx as jsx19, jsxs as jsxs13 } from "react/jsx-runtime";
+var OverviewScreen = () => {
+  const { theme } = useTheme();
+  const { tasks, overviewMonth, setOverviewMonth, setShowOverview } = useApp();
+  const [scrollOffset, setScrollOffset] = React8.useState(0);
+  const { height: terminalHeight } = useTerminalSize();
+  const visibleRows = useMemo4(() => {
+    return Math.max(2, Math.floor((terminalHeight - 9) / 3));
+  }, [terminalHeight]);
+  const monthDates = useMemo4(() => {
+    const monthStart = startOfMonth2(
+      new Date(overviewMonth.year, overviewMonth.month, 1)
+    );
+    const monthEnd = endOfMonth2(monthStart);
+    return eachDayOfInterval2({ start: monthStart, end: monthEnd });
+  }, [overviewMonth]);
+  const tasksByDate = useMemo4(() => {
+    const grouped = {};
+    monthDates.forEach((date) => {
+      const dateStr = getDateString(date);
+      grouped[dateStr] = tasks[dateStr] || [];
+    });
+    return grouped;
+  }, [monthDates, tasks]);
+  const handlePrevMonth = () => {
+    const newMonth = overviewMonth.month - 1;
+    if (newMonth < 0) {
+      setOverviewMonth({ year: overviewMonth.year - 1, month: 11 });
+    } else {
+      setOverviewMonth({ ...overviewMonth, month: newMonth });
+    }
+  };
+  const handleNextMonth = () => {
+    const newMonth = overviewMonth.month + 1;
+    if (newMonth > 11) {
+      setOverviewMonth({ year: overviewMonth.year + 1, month: 0 });
+    } else {
+      setOverviewMonth({ ...overviewMonth, month: newMonth });
+    }
+  };
+  React8.useEffect(() => {
+    setScrollOffset(0);
+  }, [overviewMonth]);
+  useInput7((input, key) => {
+    if (key.escape) {
+      setShowOverview(false);
+      return;
+    }
+    if (input === "n" || key.rightArrow) {
+      handleNextMonth();
+      return;
+    }
+    if (input === "p" || key.leftArrow) {
+      handlePrevMonth();
+      return;
+    }
+    if (input === "j" || key.downArrow) {
+      setScrollOffset(
+        (prev) => Math.min(prev + 1, Math.max(0, rows - visibleRows))
+      );
+      return;
+    }
+    if (input === "k" || key.upArrow) {
+      setScrollOffset((prev) => Math.max(prev - 1, 0));
+      return;
+    }
+  });
+  const monthName = formatDate(
+    new Date(overviewMonth.year, overviewMonth.month, 1),
+    "MMMM yyyy"
+  );
+  const columns = 4;
+  const rows = Math.ceil(monthDates.length / columns);
+  const visibleRowData = Array.from({ length: rows }).slice(
+    scrollOffset,
+    scrollOffset + visibleRows
+  );
+  const canScrollUp = scrollOffset > 0;
+  const canScrollDown = scrollOffset + visibleRows < rows;
+  return /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", padding: 1, width: "100%", height: "100%", children: [
+    /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", marginBottom: 1, children: [
+      /* @__PURE__ */ jsx19(Text11, { bold: true, color: theme.colors.focusIndicator, children: "Overview" }),
+      /* @__PURE__ */ jsx19(Text11, { color: theme.colors.foreground, children: monthName })
+    ] }),
+    /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", flexGrow: 1, children: [
+      canScrollUp && /* @__PURE__ */ jsx19(Box15, { justifyContent: "center", marginBottom: 1, children: /* @__PURE__ */ jsx19(Text11, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more above --" }) }),
+      visibleRowData.map((_, index) => {
+        const rowIndex = scrollOffset + index;
+        return /* @__PURE__ */ jsx19(Box15, { 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__ */ jsx19(
+              Box15,
+              {
+                flexDirection: "column",
+                flexGrow: 1,
+                flexBasis: 0,
+                marginRight: colIndex === columns - 1 ? 0 : 2
+              },
+              `empty-${colIndex}`
+            );
+          }
+          const dateStr = getDateString(date);
+          const dayTasks = tasksByDate[dateStr] || [];
+          const flatTasksWithDepth = [];
+          const traverse = (taskList, depth) => {
+            for (const task of taskList) {
+              flatTasksWithDepth.push({ task, depth });
+              traverse(task.children, depth + 1);
+            }
+          };
+          traverse(dayTasks, 0);
+          return /* @__PURE__ */ jsxs13(
+            Box15,
+            {
+              flexDirection: "column",
+              flexGrow: 1,
+              flexBasis: 0,
+              marginRight: colIndex === columns - 1 ? 0 : 2,
+              children: [
+                /* @__PURE__ */ jsx19(Text11, { bold: true, color: theme.colors.calendarSelected, children: formatDate(date, "do MMM") }),
+                /* @__PURE__ */ jsxs13(Box15, { flexDirection: "column", children: [
+                  flatTasksWithDepth.length === 0 ? /* @__PURE__ */ jsx19(Text11, { dimColor: true, color: theme.colors.keyboardHint, children: "No tasks" }) : flatTasksWithDepth.slice(0, 10).map(({ task, depth }) => /* @__PURE__ */ jsx19(
+                    TaskItem,
+                    {
+                      task,
+                      theme,
+                      depth
+                    },
+                    task.id
+                  )),
+                  flatTasksWithDepth.length > 10 && /* @__PURE__ */ jsxs13(Text11, { dimColor: true, color: theme.colors.keyboardHint, children: [
+                    "+",
+                    flatTasksWithDepth.length - 10,
+                    " more..."
+                  ] })
+                ] })
+              ]
+            },
+            dateStr
+          );
+        }) }, rowIndex);
+      }),
+      canScrollDown && /* @__PURE__ */ jsx19(Box15, { justifyContent: "center", marginTop: 1, children: /* @__PURE__ */ jsx19(Text11, { color: theme.colors.keyboardHint, dimColor: true, children: "-- more below --" }) })
+    ] }),
+    /* @__PURE__ */ jsx19(Box15, { marginTop: 1, children: /* @__PURE__ */ jsx19(Text11, { 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__ */ jsxs13(Box15, { children: [
+    /* @__PURE__ */ jsxs13(Text11, { color, children: [
+      checkbox,
+      " "
+    ] }),
+    depth > 0 && /* @__PURE__ */ jsx19(Text11, { children: "  ".repeat(depth) }),
+    /* @__PURE__ */ jsx19(
+      Text11,
+      {
+        color,
+        strikethrough: task.state === "completed",
+        dimColor: task.state === "delayed",
+        children: task.title.length > 35 ? task.title.slice(0, 32) + "..." : task.title
+      }
+    )
+  ] });
+};
+function getCheckbox2(state) {
+  switch (state) {
+    case "completed":
+      return "[\u2713]";
+    case "delegated":
+      return "[\u2192]";
+    case "delayed":
+      return "[\u2016]";
+    default:
+      return "[ ]";
+  }
+}
+function getStateColor2(state, theme) {
+  const colors = {
+    todo: theme.colors.taskStateTodo,
+    completed: theme.colors.taskStateCompleted,
+    delegated: theme.colors.taskStateDelegated,
+    delayed: theme.colors.taskStateDelayed
+  };
+  return colors[state] || theme.colors.foreground;
+}
+
+// src/App.tsx
+import { jsx as jsx20, jsxs as jsxs14 } from "react/jsx-runtime";
+var AppContent = () => {
+  const {
+    showHelp,
+    showOverview,
+    exitConfirmation,
+    activePane,
+    showThemeDialog,
+    showClearTimelineDialog
+  } = useApp();
+  const { theme } = useTheme();
+  useKeyboardNav();
+  const { width, height } = useTerminalSize();
+  if (showThemeDialog) {
+    return /* @__PURE__ */ jsx20(ThemeDialog, {});
+  }
+  if (showHelp) {
+    return /* @__PURE__ */ jsx20(HelpDialog, {});
+  }
+  if (showClearTimelineDialog) {
+    return /* @__PURE__ */ jsx20(ClearTimelineDialog, {});
+  }
+  return /* @__PURE__ */ jsx20(FullscreenBackground, { backgroundColor: theme.colors.background || "black", children: /* @__PURE__ */ jsxs14(Box16, { flexDirection: "column", width, height, padding: 1, backgroundColor: theme.colors.background, children: [
+    showOverview ? /* @__PURE__ */ jsx20(OverviewScreen, {}) : /* @__PURE__ */ jsx20(
+      ThreeColumnLayout,
+      {
+        leftPane: /* @__PURE__ */ jsx20(CalendarPane, {}),
+        centerPane: /* @__PURE__ */ jsx20(TasksPane, {}),
+        rightPane: /* @__PURE__ */ jsx20(TimelinePane, {}),
+        activePane,
+        height: height - 2
+      }
+    ),
+    exitConfirmation && /* @__PURE__ */ jsx20(Box16, { width: "100%", justifyContent: "center", paddingY: 1, children: /* @__PURE__ */ jsxs14(Text12, { backgroundColor: "red", color: "white", bold: true, children: [
+      " ",
+      "Press Ctrl+C again to exit Epoch",
+      " "
+    ] }) })
+  ] }) });
+};
+var App = () => {
+  return /* @__PURE__ */ jsx20(StorageProvider, { children: /* @__PURE__ */ jsx20(ThemeProvider, { initialTheme: "dark", children: /* @__PURE__ */ jsx20(AppProvider, { children: /* @__PURE__ */ jsx20(AppContent, {}) }) }) });
+};
+var App_default = App;
+
+// src/index.tsx
+import { jsx as jsx21 } from "react/jsx-runtime";
 console.clear();
-const app = render(_jsx(App, {}), { exitOnCtrlC: false });
-// Make the app instance globally accessible for clean exit
+var app = render(/* @__PURE__ */ jsx21(App_default, {}), { exitOnCtrlC: false });
 global.__inkApp = app;