openuispec 0.1.18 → 0.1.19

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/MainActivity.kt

@@ -0,0 +1,14 @@
+package uz.rsteam.todoorbit
+
+import android.os.Bundle
+import androidx.activity.ComponentActivity
+import androidx.activity.compose.setContent
+
+class MainActivity : ComponentActivity() {
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContent {
+            TodoOrbitGeneratedApp()
+        }
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/TodoOrbitApp.kt

@@ -0,0 +1,345 @@
+package uz.rsteam.todoorbit
+
+import androidx.appcompat.app.AppCompatDelegate
+import androidx.compose.animation.Crossfade
+import androidx.compose.foundation.ExperimentalFoundationApi
+import androidx.compose.foundation.layout.Arrangement
+import androidx.compose.foundation.layout.BoxWithConstraints
+import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.ExperimentalLayoutApi
+import androidx.compose.foundation.layout.Row
+import androidx.compose.foundation.layout.Spacer
+import androidx.compose.foundation.layout.fillMaxSize
+import androidx.compose.foundation.layout.height
+import androidx.compose.foundation.layout.padding
+import androidx.compose.material.icons.Icons
+import androidx.compose.material.icons.automirrored.outlined.TrendingUp
+import androidx.compose.material.icons.outlined.Checklist
+import androidx.compose.material.icons.outlined.Settings
+import androidx.compose.material3.AlertDialog
+import androidx.compose.material3.ExperimentalMaterial3Api
+import androidx.compose.material3.Icon
+import androidx.compose.material3.MaterialTheme
+import androidx.compose.material3.NavigationBar
+import androidx.compose.material3.NavigationBarItem
+import androidx.compose.material3.NavigationRail
+import androidx.compose.material3.NavigationRailItem
+import androidx.compose.material3.Scaffold
+import androidx.compose.material3.SnackbarHost
+import androidx.compose.material3.SnackbarHostState
+import androidx.compose.material3.Surface
+import androidx.compose.material3.Text
+import androidx.compose.material3.TextButton
+import androidx.compose.material3.TopAppBar
+import androidx.compose.runtime.Composable
+import androidx.compose.runtime.LaunchedEffect
+import androidx.compose.runtime.getValue
+import androidx.compose.runtime.mutableStateListOf
+import androidx.compose.runtime.mutableStateOf
+import androidx.compose.runtime.remember
+import androidx.compose.runtime.rememberCoroutineScope
+import androidx.compose.runtime.saveable.rememberSaveable
+import androidx.compose.runtime.setValue
+import androidx.compose.ui.Modifier
+import androidx.compose.ui.res.stringResource
+import androidx.compose.ui.text.font.FontWeight
+import androidx.compose.ui.unit.dp
+import androidx.core.os.LocaleListCompat
+import kotlinx.coroutines.launch
+import uz.rsteam.todoorbit.ui.theme.TodoOrbitTheme
+import java.time.LocalDate
+import java.time.LocalDateTime
+
+@OptIn(ExperimentalMaterial3Api::class, ExperimentalFoundationApi::class, ExperimentalLayoutApi::class)
+@Composable
+fun TodoOrbitGeneratedApp() {
+    var tab by rememberSaveable { mutableStateOf(ScreenTab.Tasks) }
+    var filter by rememberSaveable { mutableStateOf(TaskFilter.All) }
+    var searchQuery by rememberSaveable { mutableStateOf("") }
+    var analyticsPeriod by rememberSaveable { mutableStateOf(AnalyticsPeriod.Week) }
+    var preferences by rememberSaveable(stateSaver = PreferencesStateSaver) { mutableStateOf(PreferencesState()) }
+    var selectedTaskId by rememberSaveable { mutableStateOf(sampleTasks().first().id) }
+    var overlay by remember { mutableStateOf<OverlayState?>(null) }
+    val snackbarHostState = remember { SnackbarHostState() }
+    val scope = rememberCoroutineScope()
+    val tasks = remember { mutableStateListOf(*sampleTasks().toTypedArray()) }
+    val recurringRules = remember { mutableStateListOf<RecurringRuleModel>() }
+    val createTaskSuccessMessage = stringResource(R.string.create_task_success)
+    val editTaskSuccessMessage = stringResource(R.string.edit_task_success)
+    val recurringRuleSuccessMessage = stringResource(R.string.recurring_rule_success)
+
+    LaunchedEffect(preferences.locale) {
+        AppCompatDelegate.setApplicationLocales(
+            LocaleListCompat.forLanguageTags(preferences.locale.toLanguageTag())
+        )
+    }
+
+    TodoOrbitTheme(darkTheme = preferences.themeMode == ThemeMode.Dark) {
+        Surface(modifier = Modifier.fillMaxSize(), color = MaterialTheme.colorScheme.background) {
+            BoxWithConstraints {
+                val useRail = maxWidth >= 900.dp
+                val useSplitView = useRail && this@BoxWithConstraints.maxWidth >= 1200.dp
+                val visibleTasks = remember(tasks.toList(), filter, searchQuery) {
+                    tasks.filter { task ->
+                        val matchesFilter = when (filter) {
+                            TaskFilter.All -> true
+                            TaskFilter.Open -> task.status == TaskStatus.Open
+                            TaskFilter.Done -> task.status == TaskStatus.Done
+                        }
+                        val matchesSearch = listOf(task.title, task.notes).joinToString(" ").contains(searchQuery, ignoreCase = true)
+                        matchesFilter && matchesSearch
+                    }
+                }
+                val selectedTask = tasks.firstOrNull { it.id == selectedTaskId } ?: tasks.firstOrNull()
+                val overview = analyticsOverview(tasks)
+                val trendSeries = trendPoints(tasks, analyticsPeriod, preferences.locale)
+                val overdueTasks = tasks.filter { it.status == TaskStatus.Open && it.dueDate?.isBefore(LocalDate.now()) == true }
+
+                Scaffold(
+                    topBar = {
+                        TopAppBar(
+                            title = {
+                                Column {
+                                    Text(stringResource(R.string.app_name), fontWeight = FontWeight.Bold)
+                                    Text(
+                                        text = when (tab) {
+                                            ScreenTab.Tasks -> stringResource(R.string.app_path_home)
+                                            ScreenTab.Analytics -> stringResource(R.string.app_path_analytics)
+                                            ScreenTab.Settings -> stringResource(R.string.app_path_settings)
+                                        },
+                                        style = MaterialTheme.typography.labelSmall,
+                                        color = MaterialTheme.colorScheme.onSurfaceVariant
+                                    )
+                                }
+                            }
+                        )
+                    },
+                    bottomBar = {
+                        if (!useRail) {
+                            NavigationBar {
+                                NavigationBarItem(
+                                    selected = tab == ScreenTab.Tasks,
+                                    onClick = { tab = ScreenTab.Tasks },
+                                    icon = { Icon(Icons.Outlined.Checklist, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_tasks)) }
+                                )
+                                NavigationBarItem(
+                                    selected = tab == ScreenTab.Analytics,
+                                    onClick = { tab = ScreenTab.Analytics },
+                                    icon = { Icon(Icons.AutoMirrored.Outlined.TrendingUp, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_analytics)) }
+                                )
+                                NavigationBarItem(
+                                    selected = tab == ScreenTab.Settings,
+                                    onClick = { tab = ScreenTab.Settings },
+                                    icon = { Icon(Icons.Outlined.Settings, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_settings)) }
+                                )
+                            }
+                        }
+                    },
+                    snackbarHost = { SnackbarHost(snackbarHostState) }
+                ) { innerPadding ->
+                    Row(modifier = Modifier.fillMaxSize().padding(innerPadding)) {
+                        if (useRail) {
+                            NavigationRail(containerColor = MaterialTheme.colorScheme.surfaceVariant.copy(alpha = 0.45f)) {
+                                Spacer(Modifier.height(12.dp))
+                                NavigationRailItem(
+                                    selected = tab == ScreenTab.Tasks,
+                                    onClick = { tab = ScreenTab.Tasks },
+                                    icon = { Icon(Icons.Outlined.Checklist, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_tasks)) }
+                                )
+                                NavigationRailItem(
+                                    selected = tab == ScreenTab.Analytics,
+                                    onClick = { tab = ScreenTab.Analytics },
+                                    icon = { Icon(Icons.AutoMirrored.Outlined.TrendingUp, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_analytics)) }
+                                )
+                                NavigationRailItem(
+                                    selected = tab == ScreenTab.Settings,
+                                    onClick = { tab = ScreenTab.Settings },
+                                    icon = { Icon(Icons.Outlined.Settings, contentDescription = null) },
+                                    label = { Text(stringResource(R.string.nav_settings)) }
+                                )
+                            }
+                        }
+
+                        Crossfade(targetState = tab, modifier = Modifier.fillMaxSize(), label = "tab-crossfade") { activeTab ->
+                            when (activeTab) {
+                                ScreenTab.Tasks -> {
+                                    TasksScreen(
+                                        tasks = visibleTasks,
+                                        allTasks = tasks,
+                                        filter = filter,
+                                        searchQuery = searchQuery,
+                                        selectedTask = selectedTask,
+                                        locale = preferences.locale,
+                                        useSplitView = useSplitView,
+                                        onSearchChange = { searchQuery = it },
+                                        onFilterChange = { filter = it },
+                                        onSelectTask = { selectedTaskId = it.id },
+                                        onToggleTask = { task ->
+                                            val index = tasks.indexOfFirst { it.id == task.id }
+                                            if (index >= 0) {
+                                                tasks[index] = task.copy(
+                                                    status = if (task.status == TaskStatus.Done) TaskStatus.Open else TaskStatus.Done,
+                                                    updatedAt = LocalDateTime.now()
+                                                )
+                                            }
+                                        },
+                                        onCreateTask = { overlay = OverlayState.CreateTask },
+                                        onEditTask = { overlay = OverlayState.EditTask(it.id) },
+                                        onDeleteTask = {
+                                            tasks.removeAll { task -> task.id == it.id }
+                                            selectedTaskId = tasks.firstOrNull()?.id.orEmpty()
+                                        },
+                                        onMoreInfo = { overlay = OverlayState.TaskMeta(it.id) }
+                                    )
+                                }
+
+                                ScreenTab.Analytics -> {
+                                    AnalyticsScreen(
+                                        period = analyticsPeriod,
+                                        overview = overview,
+                                        trendSeries = trendSeries,
+                                        overdueTasks = overdueTasks,
+                                        onPeriodChange = { analyticsPeriod = it },
+                                        locale = preferences.locale
+                                    )
+                                }
+
+                                ScreenTab.Settings -> {
+                                    SettingsScreen(
+                                        preferences = preferences,
+                                        recurringRules = recurringRules,
+                                        onPreferencesChange = { preferences = it },
+                                        onOpenRecurringRule = { overlay = OverlayState.RecurringRule },
+                                        locale = preferences.locale
+                                    )
+                                }
+                            }
+                        }
+                    }
+                }
+
+                when (val currentOverlay = overlay) {
+                    OverlayState.CreateTask -> {
+                        TaskEditorSheet(
+                            draft = TaskDraft(),
+                            title = stringResource(R.string.create_task_title),
+                            saveLabel = stringResource(R.string.create_task_save),
+                            onDismiss = { overlay = null },
+                            onSubmit = { draft ->
+                                tasks.add(
+                                    0,
+                                    TaskModel(
+                                        id = "task-${System.currentTimeMillis()}",
+                                        title = draft.title.trim(),
+                                        notes = draft.notes.trim(),
+                                        status = TaskStatus.Open,
+                                        priority = draft.priority,
+                                        dueDate = draft.dueDate,
+                                        createdAt = LocalDateTime.now(),
+                                        updatedAt = LocalDateTime.now()
+                                    )
+                                )
+                                selectedTaskId = tasks.first().id
+                                overlay = null
+                                scope.launch {
+                                    snackbarHostState.showSnackbar(createTaskSuccessMessage)
+                                }
+                            }
+                        )
+                    }
+
+                    is OverlayState.EditTask -> {
+                        val task = tasks.firstOrNull { it.id == currentOverlay.taskId }
+                        if (task != null) {
+                            TaskEditorSheet(
+                                draft = TaskDraft(
+                                    title = task.title,
+                                    notes = task.notes,
+                                    priority = task.priority,
+                                    dueDate = task.dueDate
+                                ),
+                                title = stringResource(R.string.edit_task_title),
+                                saveLabel = stringResource(R.string.edit_task_save),
+                                onDismiss = { overlay = null },
+                                onSubmit = { draft ->
+                                    val index = tasks.indexOfFirst { it.id == task.id }
+                                    if (index >= 0) {
+                                        tasks[index] = task.copy(
+                                            title = draft.title.trim(),
+                                            notes = draft.notes.trim(),
+                                            priority = draft.priority,
+                                            dueDate = draft.dueDate,
+                                            updatedAt = LocalDateTime.now()
+                                        )
+                                    }
+                                    overlay = null
+                                    scope.launch {
+                                        snackbarHostState.showSnackbar(editTaskSuccessMessage)
+                                    }
+                                }
+                            )
+                        }
+                    }
+
+                    OverlayState.RecurringRule -> {
+                        RecurringRuleSheet(
+                            preferences = preferences,
+                            rules = recurringRules,
+                            locale = preferences.locale,
+                            onDismiss = { overlay = null },
+                            onSubmit = { rule ->
+                                recurringRules.add(0, rule)
+                                overlay = null
+                                scope.launch {
+                                    snackbarHostState.showSnackbar(recurringRuleSuccessMessage)
+                                }
+                            }
+                        )
+                    }
+
+                    is OverlayState.TaskMeta -> {
+                        val task = tasks.firstOrNull { it.id == currentOverlay.taskId }
+                        if (task != null) {
+                            AlertDialog(
+                                onDismissRequest = { overlay = null },
+                                title = { Text(stringResource(R.string.task_detail_more_info)) },
+                                text = {
+                                    Column(verticalArrangement = Arrangement.spacedBy(8.dp)) {
+                                        LabelValue(
+                                            stringResource(R.string.task_detail_status),
+                                            stringResource(task.status.labelRes)
+                                        )
+                                        LabelValue(
+                                            stringResource(R.string.task_detail_priority),
+                                            stringResource(task.priority.labelRes)
+                                        )
+                                        LabelValue(
+                                            stringResource(R.string.task_detail_created),
+                                            formatAbsolute(task.createdAt.toLocalDate(), preferences.locale)
+                                        )
+                                        LabelValue(
+                                            stringResource(R.string.task_detail_updated),
+                                            formatAbsolute(task.updatedAt.toLocalDate(), preferences.locale)
+                                        )
+                                    }
+                                },
+                                confirmButton = {
+                                    TextButton(onClick = { overlay = null }) {
+                                        Text(stringResource(R.string.common_cancel))
+                                    }
+                                }
+                            )
+                        }
+                    }
+
+                    null -> Unit
+                }
+            }
+        }
+    }
+}

package/examples/todo-orbit/generated/android/Todo Orbit/app/src/main/java/uz/rsteam/todoorbit/support/AppLogic.kt

@@ -0,0 +1,231 @@
+package uz.rsteam.todoorbit
+
+import java.time.LocalDate
+import java.time.LocalDateTime
+import java.time.format.DateTimeFormatter
+import java.time.format.FormatStyle
+import java.util.Locale
+import kotlin.math.roundToInt
+
+data class AnalyticsOverview(
+    val completedToday: Int,
+    val openTasks: Int,
+    val overdueTasks: Int,
+    val completionRate: Int
+)
+
+fun analyticsOverview(tasks: List<TaskModel>): AnalyticsOverview {
+    val today = LocalDate.now()
+    val completedToday = tasks.count { it.status == TaskStatus.Done && it.updatedAt.toLocalDate() == today }
+    val openTasks = tasks.count { it.status == TaskStatus.Open }
+    val overdueTasks = tasks.count { it.status == TaskStatus.Open && it.dueDate?.isBefore(today) == true }
+    val completionRate = if (tasks.isEmpty()) 0 else (((tasks.size - openTasks).toFloat() / tasks.size) * 100f).roundToInt()
+    return AnalyticsOverview(completedToday, openTasks, overdueTasks, completionRate)
+}
+
+fun trendPoints(tasks: List<TaskModel>, period: AnalyticsPeriod, locale: UiLocale): List<TrendPoint> {
+    val length = when (period) {
+        AnalyticsPeriod.Week -> 7
+        AnalyticsPeriod.Month -> 6
+        AnalyticsPeriod.Quarter -> 8
+    }
+    val formatter = when (locale) {
+        UiLocale.En -> DateTimeFormatter.ofPattern(if (period == AnalyticsPeriod.Week) "EEE" else "MMM d", Locale.ENGLISH)
+        UiLocale.Ru -> DateTimeFormatter.ofPattern(if (period == AnalyticsPeriod.Week) "EEE" else "d MMM", Locale("ru"))
+    }
+    val today = LocalDate.now()
+    return (0 until length).map { index ->
+        val cursor = today.minusDays(((length - index - 1) * if (period == AnalyticsPeriod.Week) 1 else 5).toLong())
+        TrendPoint(
+            label = cursor.format(formatter),
+            completed = tasks.count { it.status == TaskStatus.Done && !it.updatedAt.toLocalDate().isAfter(cursor) },
+            created = tasks.count { !it.createdAt.toLocalDate().isAfter(cursor) }
+        )
+    }
+}
+
+fun validateRuleDraft(
+    draft: RuleDraft,
+    preferences: PreferencesState,
+    rules: List<RecurringRuleModel>
+): Map<String, UiText> {
+    val errors = mutableMapOf<String, UiText>()
+    val trimmedName = draft.name.trim()
+    if (trimmedName.length < 4) {
+        errors["name"] = UiText.Resource(R.string.validation_rule_name_min_length, listOf(4))
+    } else if (trimmedName == "Default") {
+        errors["name"] = UiText.Resource(R.string.validation_rule_name_reserved)
+    } else if (rules.any { it.name.equals(trimmedName, ignoreCase = true) }) {
+        errors["name"] = UiText.Resource(R.string.validation_rule_name_taken)
+    }
+
+    if (draft.confirmName.trim() != trimmedName) {
+        errors["confirmName"] = UiText.Resource(R.string.validation_match_field)
+    }
+
+    val interval = draft.interval.toIntOrNull()
+    when {
+        interval == null || interval < 1 -> errors["interval"] = UiText.Resource(R.string.validation_min_value, listOf(1))
+        interval > 30 -> errors["interval"] = UiText.Resource(R.string.validation_max_value, listOf(30))
+    }
+
+    if (draft.cadence == null) {
+        errors["cadence"] = UiText.Resource(R.string.validation_fix_errors)
+    }
+
+    if (draft.cadence == Cadence.Weekly && draft.weekday == null) {
+        errors["weekday"] = UiText.Resource(R.string.validation_fix_errors)
+    }
+
+    if (draft.cadence == Cadence.Monthly) {
+        val monthDay = draft.monthDay.toIntOrNull()
+        when {
+            monthDay == null || monthDay < 1 -> errors["monthDay"] = UiText.Resource(R.string.validation_min_value, listOf(1))
+            monthDay > 28 -> errors["monthDay"] = UiText.Resource(R.string.validation_month_day_max)
+        }
+    }
+
+    if (draft.hasEndDate && draft.endDate != null && draft.endDate.isBefore(draft.startDate)) {
+        errors["endDate"] = UiText.Resource(R.string.validation_end_date_after_start)
+    }
+
+    if (preferences.remindersEnabled && !Regex("^([01]\\d|2[0-3]):[0-5]\\d$").matches(draft.remindAt)) {
+        errors["remindAt"] = UiText.Resource(R.string.validation_time_format)
+    }
+
+    if (draft.enableSummary && draft.summaryChannel == null) {
+        errors["summaryChannel"] = UiText.Resource(R.string.validation_fix_errors)
+    }
+
+    return errors
+}
+
+fun schedulePreview(draft: RuleDraft): SchedulePreviewState {
+    val interval = draft.interval.toIntOrNull() ?: return SchedulePreviewState(PreviewMode.Invalid)
+    val cadence = draft.cadence ?: return SchedulePreviewState(PreviewMode.Invalid)
+    if (interval < 1) return SchedulePreviewState(PreviewMode.Invalid)
+    if (draft.hasEndDate && draft.endDate != null && draft.endDate.isBefore(draft.startDate)) {
+        return SchedulePreviewState(PreviewMode.Invalid)
+    }
+    if (cadence == Cadence.Weekly && draft.weekday == null) return SchedulePreviewState(PreviewMode.Invalid)
+    val monthlyDay = if (cadence == Cadence.Monthly) draft.monthDay.toIntOrNull() ?: return SchedulePreviewState(PreviewMode.Invalid) else null
+
+    val result = mutableListOf<LocalDate>()
+    var cursor = draft.startDate
+    repeat(4) {
+        val next = when (cadence) {
+            Cadence.Daily -> cursor
+            Cadence.Weekly -> nextWeekdayFrom(cursor, draft.weekday!!)
+            Cadence.Monthly -> nextMonthlyFrom(cursor, monthlyDay!!)
+        }
+        if (draft.endDate != null && next.isAfter(draft.endDate)) return@repeat
+        result += next
+        cursor = when (cadence) {
+            Cadence.Daily -> next.plusDays(interval.toLong())
+            Cadence.Weekly -> next.plusWeeks(interval.toLong())
+            Cadence.Monthly -> next.plusMonths(interval.toLong())
+        }
+    }
+
+    return if (result.isEmpty()) SchedulePreviewState(PreviewMode.Empty) else SchedulePreviewState(PreviewMode.Ready, result)
+}
+
+fun formatAbsolute(date: LocalDate, locale: UiLocale): String {
+    val formatter = when (locale) {
+        UiLocale.En -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale.ENGLISH)
+        UiLocale.Ru -> DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM).withLocale(Locale("ru"))
+    }
+    return formatter.format(date)
+}
+
+fun parseLocalDateOrNull(value: String): LocalDate? {
+    return runCatching {
+        value.takeIf(String::isNotBlank)?.let(LocalDate::parse)
+    }.getOrNull()
+}
+
+private fun nextWeekdayFrom(date: LocalDate, weekday: Weekday): LocalDate {
+    var cursor = date
+    while (cursor.dayOfWeek.value != weekdayToDayNumber(weekday)) {
+        cursor = cursor.plusDays(1)
+    }
+    return cursor
+}
+
+private fun nextMonthlyFrom(date: LocalDate, day: Int): LocalDate {
+    val base = date.withDayOfMonth(1)
+    val candidate = base.withDayOfMonth(day.coerceAtMost(base.lengthOfMonth()))
+    return if (candidate.isBefore(date)) {
+        base.plusMonths(1).withDayOfMonth(day.coerceAtMost(base.plusMonths(1).lengthOfMonth()))
+    } else {
+        candidate
+    }
+}
+
+private fun weekdayToDayNumber(weekday: Weekday): Int {
+    return when (weekday) {
+        Weekday.Mon -> 1
+        Weekday.Tue -> 2
+        Weekday.Wed -> 3
+        Weekday.Thu -> 4
+        Weekday.Fri -> 5
+        Weekday.Sat -> 6
+        Weekday.Sun -> 7
+    }
+}
+
+fun sampleTasks(): List<TaskModel> {
+    val now = LocalDateTime.now()
+    return listOf(
+        TaskModel(
+            id = "task-1",
+            title = "Prepare bilingual launch notes",
+            notes = "Document the web, iOS, and Android behavior differences before review.",
+            status = TaskStatus.Open,
+            priority = Priority.High,
+            dueDate = LocalDate.now().plusDays(2),
+            createdAt = now.minusDays(6),
+            updatedAt = now.minusDays(1)
+        ),
+        TaskModel(
+            id = "task-2",
+            title = "Review recurring-rule validation",
+            notes = "Confirm async uniqueness checks and cross-field constraints.",
+            status = TaskStatus.Done,
+            priority = Priority.Medium,
+            dueDate = LocalDate.now().minusDays(1),
+            createdAt = now.minusDays(5),
+            updatedAt = now
+        ),
+        TaskModel(
+            id = "task-3",
+            title = "Polish analytics empty states",
+            notes = "Ensure chart and overdue list degrade gracefully on zero-data snapshots.",
+            status = TaskStatus.Open,
+            priority = Priority.Medium,
+            dueDate = LocalDate.now().plusDays(5),
+            createdAt = now.minusDays(4),
+            updatedAt = now.minusDays(2)
+        ),
+        TaskModel(
+            id = "task-4",
+            title = "Regenerate drift snapshots",
+            notes = "Refresh ios, android, and web state after spec edits.",
+            status = TaskStatus.Open,
+            priority = Priority.Low,
+            dueDate = LocalDate.now().minusDays(3),
+            createdAt = now.minusDays(3),
+            updatedAt = now.minusDays(3)
+        ),
+        TaskModel(
+            id = "task-5",
+            title = "Prototype schedule preview contract",
+            notes = "Use derived occurrences to prove custom-contract generation.",
+            status = TaskStatus.Done,
+            priority = Priority.High,
+            dueDate = LocalDate.now().plusDays(1),
+            createdAt = now.minusDays(8),
+            updatedAt = now.minusDays(1)
+        )
+    )
+}