From b3b60d1fd430956d1bb77cf896d380f0e03bb7ba Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 17 Oct 2026 01:43:10 +0000
Subject: [PATCH 1/2] feat: start day from the task board and pick planned
 tasks on an empty day

Add startDayAndPullPlannedTask, a Start Day button on the Tasks page, and a
planned task picker for started days with no tasks. Share pull/add logic via
startPlannedTaskInDay and pass day state explicitly to beginTask so a day and
its first task persist correctly in one tick.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FpA8FnKDt9kkxMjnfUU7uU
---
 AGENTS.md                                 |   4 +-
 CHANGELOG.md                              |   4 +
 README-EXT.md                             |   1 +
 README.md                                 |   2 +-
 src/components/PlannedTaskCard.tsx        |  27 ++++-
 src/components/PlannedTaskPicker.test.tsx |  81 +++++++++++++
 src/components/PlannedTaskPicker.tsx      |  90 +++++++++++++++
 src/contexts/TimeTracking.test.tsx        | 131 ++++++++++++++++++++++
 src/contexts/TimeTrackingContext.tsx      | 106 +++++++++++------
 src/pages/Index.tsx                       |   5 +-
 src/pages/TaskList.tsx                    |  30 +++--
 11 files changed, 434 insertions(+), 47 deletions(-)
 create mode 100644 src/components/PlannedTaskPicker.test.tsx
 create mode 100644 src/components/PlannedTaskPicker.tsx

diff --git a/AGENTS.md b/AGENTS.md
index 118e581..59aa127 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -22,7 +22,7 @@ Timetraked is a React 18 + TypeScript time tracking PWA for freelancers and cons
 - When fixing a bug, add a regression test as part of the same change.
 - Verify version alignment between related dev tools (e.g., vitest + @vitest/coverage) when test errors appear.
 
-### Test File Inventory (~376 JS/TS tests across 36 files, plus 17 Rust unit tests across `src-tauri/src/backup.rs`/`menu.rs`/`quit_flush.rs` run via `cargo test`)
+### Test File Inventory (~390 JS/TS tests across 37 files, plus 17 Rust unit tests across `src-tauri/src/backup.rs`/`menu.rs`/`quit_flush.rs` run via `cargo test`)
 
 | File | Coverage |
 |---|---|
@@ -49,6 +49,7 @@ Timetraked is a React 18 + TypeScript time tracking PWA for freelancers and cons
 | `src/components/SummaryOutput.test.tsx` | Summary output rendering |
 | `src/components/NewTaskForm.test.tsx` | Form render, submit, validation, cancel, FAB toggle |
 | `src/components/TaskItem.test.tsx` | Badge render, delete confirm, edit dialog |
+| `src/components/PlannedTaskPicker.test.tsx` | Dashboard empty-day picker: ordering, filtering, start vs resume, list cap |
 | `src/components/ArchiveEditDialog.test.tsx` | Archive edit dialog render and task editing flow |
 | `src/components/ArchivedTaskRow.test.tsx` | Inline expandable archived task row editing |
 | `src/components/dateParsing.test.ts` | Date parsing utilities |
@@ -170,6 +171,7 @@ export const MyComponent = () => {
 | `src/components/BackdatedEntryDialog.tsx`     | Multi-step dialog for logging past workdays; uses `addBackdatedDay` from context   |
 | `src/hooks/useLongPress.ts`                   | 500 ms hold detector for context menu trigger on touch                             |
 | `src/components/ui/responsive-select.tsx`     | `ResponsiveSelect` — branches on `useIsMobile()` to render a native `<select>` on mobile (OS picker) vs the Radix `Select` on desktop; flat `options` array API shared by `NewTaskForm`, `ProjectSheet`, `BackdatedEntryDialog`, `PlannedTaskDialog`, `ArchivedTaskRow` |
+| `src/components/PlannedTaskPicker.tsx`        | Empty started-day card on the Dashboard: lists in-progress/to-do planned tasks with Start (`pullPlannedTaskToDay`) / Resume (`addPlannedTaskToDay`) buttons. Task Board cards and the Tasks page header can also start the day (`startDayAndPullPlannedTask`, "now" rounded to 15 min, no dialog) |
 | `src/components/ArchivedTaskRow.tsx`          | Inline expandable row for editing a single task within `ArchiveEditDialog` (replaces the old `TaskEditInArchiveDialog` modal) |
 | `src/services/localStorageService/recovery.ts` | Lists/previews/restores localStorage schema-mismatch backup keys and desktop (Tauri) disk-backup snapshots; the read side of the write-only backup safety nets |
 | `src/hooks/useDataRecovery.ts`                | Unifies browser (`recovery.ts`) and desktop (`useElectronBackup`'s `listDiskBackups`/`readDiskBackup`, Tauri-backed) backup sources behind one list/preview/restore API |
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 12da318..ea0f1bd 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- Starting a day from the task board no longer requires a detour through the Dashboard. The Tasks page header has a "Start Day" button (starts at the current time, rounded to 15 minutes, without the start-time dialog), and each planned task's menu offers "Start Day and Pull" (or "Start Day and Resume" for in-progress tasks) when no day is running. New context method `startDayAndPullPlannedTask` starts the day and the task in one step; it is blocked while an ended day is still awaiting posting. Pull/add/start-day-and-pull share one internal helper, and `startNewTask` now delegates to an internal `beginTask` that takes the day state explicitly so a day and its first task can be created in the same tick without a stale-closure save
+  — `src/contexts/TimeTrackingContext.tsx`, `src/components/PlannedTaskCard.tsx`, `src/pages/TaskList.tsx`
+- A started day with no tasks now shows a "Pick up a planned task" card on the Dashboard (up to five in-progress or to-do planned tasks with Start/Resume buttons, plus a link to the Task Board) instead of force-opening the new task form
+  — `src/components/PlannedTaskPicker.tsx` (new), `src/pages/Index.tsx`
 - Users can now add tasks directly to an existing archived day from the ArchiveEditDialog — a toggleable "Add Task" button in the task table header opens an inline form (title, description, category, project, start/end time) that appends the task and recalculates the day's total duration on save. Context method `addTaskToArchivedDay` handles the optimistic update and persistence
   — `src/components/ArchiveEditDialog.tsx`, `src/contexts/TimeTrackingContext.tsx`
 - Scaffolded a Tauri iOS build target alongside the existing Mac/Windows desktop app, so the app can now be run in the iOS Simulator (`pnpm tauri:ios:init`, `pnpm tauri:ios:dev`) and eventually shipped to the App Store. Split `src-tauri/src/main.rs` into a shared `lib.rs` (`#[cfg_attr(mobile, tauri::mobile_entry_point)]`) with a thin binary wrapper, and added a `[lib]` crate target (`crate-type = ["staticlib", "cdylib", "rlib"]`) required for mobile builds. The native menu, self-hosted updater, and updater-triggered restart — none of which apply on iOS — are now compiled out on mobile via `#[cfg(desktop)]`; their Tauri permissions moved to a new desktop-only capabilities file (`capabilities/desktop.json`, scoped via `"platforms"`). Added `src-tauri/tauri.ios.conf.json` to override the Tauri `identifier` to the App Store bundle ID (`com.adamjolicoeur.timetraked`) on iOS only, leaving the existing desktop identifier (and its app-data dir/keychain/updater identity) untouched. Also closed a touch-accessibility gap found during the investigation: the command palette (`Cmd/Ctrl+K`) previously had no on-screen trigger, only a keyboard shortcut and a desktop-only menu item — added a header button so it's reachable on iOS, which has neither. `src/lib/platform.ts` gained an `isIOS` check (touch-point-qualified, since iPadOS spoofs a "Macintosh" user agent) used to fix `isMac` misdetecting iPhone/iPad and to gate the startup silent-update check off on iOS. Corrected `index.html`'s CSP, which allowlisted a stale `capacitor://localhost` left over from an earlier Capacitor-based plan (this project ships via Tauri). CI/App Store Connect signing automation is an explicit follow-up, not included here
diff --git a/README-EXT.md b/README-EXT.md
index 9ddabfa..75d33a8 100644
--- a/README-EXT.md
+++ b/README-EXT.md
@@ -417,6 +417,7 @@ src/
 │   ├── PageLayout.tsx             # Delegates title/badge/actions to PageTitleContext
 │   ├── PlannedTaskCard.tsx
 │   ├── PlannedTaskDialog.tsx
+│   ├── PlannedTaskPicker.tsx
 │   ├── ProjectManagement.tsx
 │   ├── ProjectSheet.tsx
 │   ├── PwaUpdatePrompt.tsx
diff --git a/README.md b/README.md
index 8f41aff..12c18a9 100644
--- a/README.md
+++ b/README.md
@@ -138,7 +138,7 @@ See [CHANGELOG.md](CHANGELOG.md) for the full history of changes.
 - **Guest-mode data durability** — schema-mismatch backups, write-failure toasts, undo for hard deletes, Tauri desktop disk-based backup snapshots (independent of `localStorage`, including a final flush on app quit), and an in-app "Data Recovery" UI in Settings to preview and restore those backups
 - **Self-hosted SQL backend** — opt-in PostgreSQL/MySQL support via a small REST API (`server/`), alongside the existing Supabase and local storage modes
 - **Backdated entry creation** — "Add Past Entry" button on Archive page opens a multi-step dialog to log tasks for any past date
-- **Kanban planning board** — drag-and-drop task planning view (`KanbanBoard`, `KanbanColumn`, `PlannedTaskCard`)
+- **Kanban planning board** — drag-and-drop task planning view (`KanbanBoard`, `KanbanColumn`, `PlannedTaskCard`); start the day (and a task) straight from the board, or pick a planned task from the Dashboard's empty-day card (`PlannedTaskPicker`)
 - Persistent report summaries saved to localStorage; markdown preview/export in the report output panel
 - `AppSidebar` collapsible sidebar navigation with live session timer; `PageTitleContext` decouples page header state from layout
 
diff --git a/src/components/PlannedTaskCard.tsx b/src/components/PlannedTaskCard.tsx
index 22fe71a..41b59fc 100644
--- a/src/components/PlannedTaskCard.tsx
+++ b/src/components/PlannedTaskCard.tsx
@@ -36,7 +36,7 @@ import {
 } from "@/components/ui/sheet";
 import { MarkdownDisplay } from "@/components/MarkdownDisplay";
 import { Badge } from "@/components/ui/badge";
-import { Edit, Trash2, Play, MoveRight, MoreVertical, PencilIcon, Briefcase, Tag, Users, PlusCircle, Clock } from "lucide-react";
+import { Edit, Trash2, Play, MoveRight, MoreVertical, PencilIcon, Briefcase, Tag, Users, PlusCircle, Clock, CirclePlay } from "lucide-react";
 import { DropdownMenuSeparator } from "@/components/ui/dropdown-menu";
 
 interface PlannedTaskCardProps {
@@ -78,6 +78,8 @@ const PlannedTaskCardComponent: React.FC<PlannedTaskCardProps> = ({
     movePlannedTask,
     pullPlannedTaskToDay,
     addPlannedTaskToDay,
+    startDayAndPullPlannedTask,
+    tasks,
   } = useTimeTracking();
   const { confirmDelete } = useUndoableDelete<PlannedTask>();
   const contextMenuTriggerRef = useRef<HTMLDivElement>(null);
@@ -95,6 +97,9 @@ const PlannedTaskCardComponent: React.FC<PlannedTaskCardProps> = ({
   const category = categories.find((c) => c.id === task.category);
   const canPull = isDayStarted && !isDayStale && task.status !== "done" && task.status !== "in_progress";
   const canAddToDay = isDayStarted && !isDayStale && task.status === "in_progress";
+  // No day running and no ended-but-unposted day waiting: start one from here.
+  const canStartDayAndPull = !isDayStarted && tasks.length === 0 && task.status !== "done";
+  const startDayLabel = task.status === "in_progress" ? "Start Day and Resume" : "Start Day and Pull";
 
   return (
     <>
@@ -191,6 +196,17 @@ const PlannedTaskCardComponent: React.FC<PlannedTaskCardProps> = ({
                             <DropdownMenuSeparator />
                           </DropdownMenuGroup>
                         )}
+                        {canStartDayAndPull && (
+                          <DropdownMenuGroup>
+                            <DropdownMenuItem
+                              onClick={() => startDayAndPullPlannedTask(task.id)}
+                            >
+                              <CirclePlay className="w-3 h-3 mr-1" />
+                              {startDayLabel}
+                            </DropdownMenuItem>
+                            <DropdownMenuSeparator />
+                          </DropdownMenuGroup>
+                        )}
                         {canAddToDay && (
                           <DropdownMenuGroup>
                             <DropdownMenuItem
@@ -259,6 +275,15 @@ const PlannedTaskCardComponent: React.FC<PlannedTaskCardProps> = ({
               <ContextMenuSeparator />
             </>
           )}
+          {canStartDayAndPull && (
+            <>
+              <ContextMenuItem onClick={() => startDayAndPullPlannedTask(task.id)}>
+                <CirclePlay className="w-4 h-4 mr-2" />
+                {startDayLabel}
+              </ContextMenuItem>
+              <ContextMenuSeparator />
+            </>
+          )}
           {canAddToDay && (
             <>
               <ContextMenuItem onClick={() => addPlannedTaskToDay(task.id)}>
diff --git a/src/components/PlannedTaskPicker.test.tsx b/src/components/PlannedTaskPicker.test.tsx
new file mode 100644
index 0000000..fd77b02
--- /dev/null
+++ b/src/components/PlannedTaskPicker.test.tsx
@@ -0,0 +1,81 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, fireEvent } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { PlannedTaskPicker } from "@/components/PlannedTaskPicker";
+import type { PlannedTask } from "@/contexts/TimeTrackingContext";
+
+const pullPlannedTaskToDay = vi.fn();
+const addPlannedTaskToDay = vi.fn();
+let plannedTasks: PlannedTask[] = [];
+
+vi.mock("@/hooks/useTimeTracking", () => ({
+  useTimeTracking: () => ({ plannedTasks, pullPlannedTaskToDay, addPlannedTaskToDay }),
+}));
+
+const makeTask = (overrides: Partial<PlannedTask>): PlannedTask => ({
+  id: "t1",
+  title: "Task",
+  status: "todo",
+  priority: 1,
+  createdAt: "2026-01-01T00:00:00.000Z",
+  updatedAt: "2026-01-01T00:00:00.000Z",
+  timeEntries: [],
+  timeSpent: 0,
+  ...overrides,
+}) as PlannedTask;
+
+const renderPicker = () =>
+  render(
+    <MemoryRouter>
+      <PlannedTaskPicker />
+    </MemoryRouter>,
+  );
+
+describe("PlannedTaskPicker", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    plannedTasks = [];
+  });
+
+  it("shows an empty message and a board link when nothing is startable", () => {
+    plannedTasks = [makeTask({ id: "d", title: "Finished", status: "done" })];
+    renderPicker();
+    expect(screen.getByText("No planned tasks are ready to start.")).toBeInTheDocument();
+    expect(screen.getByRole("link", { name: "Open the Task Board" })).toHaveAttribute("href", "/tasks");
+  });
+
+  it("lists in-progress tasks first and omits done and blocked tasks", () => {
+    plannedTasks = [
+      makeTask({ id: "a", title: "Todo task", status: "todo", priority: 1 }),
+      makeTask({ id: "b", title: "Active task", status: "in_progress", priority: 2 }),
+      makeTask({ id: "c", title: "Blocked task", status: "blocked" }),
+      makeTask({ id: "d", title: "Done task", status: "done" }),
+    ];
+    renderPicker();
+    const items = screen.getAllByRole("listitem");
+    expect(items).toHaveLength(2);
+    expect(items[0]).toHaveTextContent("Active task");
+    expect(items[1]).toHaveTextContent("Todo task");
+  });
+
+  it("pulls a todo task and resumes an in-progress task", () => {
+    plannedTasks = [
+      makeTask({ id: "a", title: "Todo task", status: "todo" }),
+      makeTask({ id: "b", title: "Active task", status: "in_progress" }),
+    ];
+    renderPicker();
+    fireEvent.click(screen.getByRole("button", { name: "Start Todo task" }));
+    expect(pullPlannedTaskToDay).toHaveBeenCalledWith("a");
+    fireEvent.click(screen.getByRole("button", { name: "Resume Active task" }));
+    expect(addPlannedTaskToDay).toHaveBeenCalledWith("b");
+  });
+
+  it("caps the list and links to the full board", () => {
+    plannedTasks = Array.from({ length: 7 }, (_, i) =>
+      makeTask({ id: `t${i}`, title: `Task ${i}`, priority: i }),
+    );
+    renderPicker();
+    expect(screen.getAllByRole("listitem")).toHaveLength(5);
+    expect(screen.getByRole("link", { name: "View all 7 on the Task Board" })).toBeInTheDocument();
+  });
+});
diff --git a/src/components/PlannedTaskPicker.tsx b/src/components/PlannedTaskPicker.tsx
new file mode 100644
index 0000000..1ad865b
--- /dev/null
+++ b/src/components/PlannedTaskPicker.tsx
@@ -0,0 +1,90 @@
+import React, { useMemo } from "react";
+import { Link } from "react-router-dom";
+import { useTimeTracking } from "@/hooks/useTimeTracking";
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
+import { Button } from "@/components/ui/button";
+import { Badge } from "@/components/ui/badge";
+import { Briefcase, Play } from "lucide-react";
+
+const MAX_VISIBLE = 5;
+
+/**
+ * Empty-day state for the Dashboard: lists planned tasks that can be started
+ * right away so a day doesn't need a hand-typed first task. In-progress tasks
+ * come first (resume), then to-do by priority.
+ */
+export const PlannedTaskPicker: React.FC = () => {
+  const { plannedTasks, pullPlannedTaskToDay, addPlannedTaskToDay } = useTimeTracking();
+
+  const candidates = useMemo(
+    () =>
+      plannedTasks
+        .filter((t) => t.status === "in_progress" || t.status === "todo")
+        .sort(
+          (a, b) =>
+            Number(b.status === "in_progress") - Number(a.status === "in_progress") ||
+            a.priority - b.priority ||
+            a.createdAt.localeCompare(b.createdAt),
+        ),
+    [plannedTasks],
+  );
+  const visible = candidates.slice(0, MAX_VISIBLE);
+
+  return (
+    <Card>
+      <CardHeader>
+        <CardTitle>Pick up a planned task</CardTitle>
+        <CardDescription>
+          Start from your task board, or use Add Task above for something new.
+        </CardDescription>
+      </CardHeader>
+      <CardContent className="space-y-2">
+        {visible.length === 0 ? (
+          <p className="text-sm text-muted-foreground">
+            No planned tasks are ready to start.
+          </p>
+        ) : (
+          <ul className="space-y-2">
+            {visible.map((task) => {
+              const resuming = task.status === "in_progress";
+              return (
+                <li
+                  key={task.id}
+                  className="flex items-center justify-between gap-2 rounded-lg border p-2"
+                >
+                  <div className="min-w-0">
+                    <p className="truncate text-sm font-medium">{task.title}</p>
+                    {task.project && (
+                      <Badge variant="outline" className="mt-1 border-mauve-7 text-mauve-11">
+                        <Briefcase className="w-2.5 h-2.5 inline mr-0.5" />
+                        {task.project}
+                      </Badge>
+                    )}
+                  </div>
+                  <Button
+                    size="sm"
+                    variant="outline"
+                    aria-label={`${resuming ? "Resume" : "Start"} ${task.title}`}
+                    onClick={() =>
+                      resuming ? addPlannedTaskToDay(task.id) : pullPlannedTaskToDay(task.id)
+                    }
+                  >
+                    <Play className="w-3 h-3 mr-1" />
+                    {resuming ? "Resume" : "Start"}
+                  </Button>
+                </li>
+              );
+            })}
+          </ul>
+        )}
+        <Button asChild variant="link" size="sm" className="px-0">
+          <Link to="/tasks">
+            {candidates.length > MAX_VISIBLE
+              ? `View all ${candidates.length} on the Task Board`
+              : "Open the Task Board"}
+          </Link>
+        </Button>
+      </CardContent>
+    </Card>
+  );
+};
diff --git a/src/contexts/TimeTracking.test.tsx b/src/contexts/TimeTracking.test.tsx
index 4e8d295..7a3e900 100644
--- a/src/contexts/TimeTracking.test.tsx
+++ b/src/contexts/TimeTracking.test.tsx
@@ -999,6 +999,137 @@ describe("TimeTrackingContext", () => {
     });
   });
 
+  describe("Start day from task board", () => {
+    it("startDayAndPullPlannedTask starts the day and the task together", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.addPlannedTask({ title: "Morning task" });
+      });
+      let taskId = "";
+      await waitFor(() => { taskId = result.current.plannedTasks[0].id; });
+
+      await act(async () => {
+        result.current.startDayAndPullPlannedTask(taskId);
+      });
+
+      await waitFor(() => {
+        expect(result.current.isDayStarted).toBe(true);
+        expect(result.current.dayStartTime).not.toBeNull();
+        expect(result.current.currentTask?.title).toBe("Morning task");
+        expect(result.current.plannedTasks[0].status).toBe("in_progress");
+        expect(result.current.plannedTasks[0].timeEntries).toHaveLength(1);
+      });
+      // First task of the day is stamped with the day start time
+      expect(result.current.currentTask?.startTime).toEqual(result.current.dayStartTime);
+    });
+
+    it("startDayAndPullPlannedTask resumes an in-progress task without relinking it", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.addPlannedTask({ title: "Carry over" });
+      });
+      let taskId = "";
+      await waitFor(() => { taskId = result.current.plannedTasks[0].id; });
+      await act(async () => {
+        result.current.movePlannedTask(taskId, "in_progress");
+      });
+
+      await act(async () => {
+        result.current.startDayAndPullPlannedTask(taskId);
+      });
+
+      await waitFor(() => {
+        expect(result.current.isDayStarted).toBe(true);
+        expect(result.current.tasks.map(t => t.title)).toEqual(["Carry over"]);
+        expect(result.current.plannedTasks[0].status).toBe("in_progress");
+        expect(result.current.plannedTasks[0].linkedTaskId).toBeUndefined();
+        expect(result.current.plannedTasks[0].timeEntries).toHaveLength(1);
+      });
+    });
+
+    it("startDayAndPullPlannedTask is blocked while an ended day awaits posting", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.addPlannedTask({ title: "Next up" });
+      });
+      let taskId = "";
+      await waitFor(() => { taskId = result.current.plannedTasks[0].id; });
+
+      await act(async () => {
+        result.current.startDay();
+      });
+      await act(async () => {
+        result.current.startNewTask("Earlier work");
+      });
+      await act(async () => {
+        result.current.endDay();
+      });
+
+      await act(async () => {
+        result.current.startDayAndPullPlannedTask(taskId);
+      });
+
+      expect(result.current.isDayStarted).toBe(false);
+      expect(result.current.plannedTasks[0].status).toBe("todo");
+      expect(result.current.tasks).toHaveLength(1);
+    });
+
+    it("startDayAndPullPlannedTask delegates to a normal pull when the day is already started", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.startDay();
+      });
+      await act(async () => {
+        result.current.addPlannedTask({ title: "Already running day" });
+      });
+      let taskId = "";
+      await waitFor(() => { taskId = result.current.plannedTasks[0].id; });
+
+      await act(async () => {
+        result.current.startDayAndPullPlannedTask(taskId);
+      });
+
+      await waitFor(() => {
+        expect(result.current.plannedTasks[0].status).toBe("in_progress");
+        expect(result.current.tasks).toHaveLength(1);
+      });
+    });
+
+    it("addPlannedTaskToDay logs a time entry for an in-progress task", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.startDay();
+      });
+      await act(async () => {
+        result.current.addPlannedTask({ title: "Resume me" });
+      });
+      let taskId = "";
+      await waitFor(() => { taskId = result.current.plannedTasks[0].id; });
+      await act(async () => {
+        result.current.movePlannedTask(taskId, "in_progress");
+      });
+
+      await act(async () => {
+        result.current.addPlannedTaskToDay(taskId);
+      });
+
+      await waitFor(() => {
+        expect(result.current.tasks.some(t => t.title === "Resume me")).toBe(true);
+        expect(result.current.plannedTasks[0].timeEntries).toHaveLength(1);
+      });
+    });
+  });
+
   describe("Project Management", () => {
     it("adds a project", async () => {
       const { result } = renderHook(() => useTimeTracking(), { wrapper });
diff --git a/src/contexts/TimeTrackingContext.tsx b/src/contexts/TimeTrackingContext.tsx
index 6f19c55..f782ca1 100644
--- a/src/contexts/TimeTrackingContext.tsx
+++ b/src/contexts/TimeTrackingContext.tsx
@@ -244,6 +244,7 @@ interface TimeTrackingContextType {
   movePlannedTask: (id: string, status: PlannedTaskStatus) => void;
   pullPlannedTaskToDay: (id: string) => void;
   addPlannedTaskToDay: (id: string) => void;
+  startDayAndPullPlannedTask: (id: string) => void;
 
   // Calculated values
   getTotalHoursForPeriod: (startDate: Date, endDate: Date) => number;
@@ -802,7 +803,11 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     }
   }, [dataService]);
 
-  const startNewTask = useCallback((
+  // `day` is passed explicitly (rather than read from state) so a caller can
+  // start a day and its first task in the same tick without a stale closure
+  // persisting `isDayStarted: false`.
+  const beginTask = useCallback((
+    day: { isDayStarted: boolean; dayStartTime: Date | null },
     title: string,
     description?: string,
     project?: string,
@@ -827,7 +832,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
 
     // Determine start time: use dayStartTime for first task, otherwise use current time
     const taskStartTime =
-      tasks.length === 0 && dayStartTime ? dayStartTime : now;
+      tasks.length === 0 && day.dayStartTime ? day.dayStartTime : now;
 
     // Create new task
     const newTask: Task = {
@@ -846,12 +851,22 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     setHasUnsavedChanges(true);
     // Save with freshly computed state to avoid reading from stale latestStateRef
     if (dataService) {
-      dataService.saveCurrentDay({ isDayStarted, dayStartTime, currentTask: newTask, tasks: updatedTasks })
+      dataService.saveCurrentDay({ isDayStarted: day.isDayStarted, dayStartTime: day.dayStartTime, currentTask: newTask, tasks: updatedTasks })
         .then(() => setLastSyncTime(new Date()))
         .catch(error => console.error("❌ Error saving after starting task:", error));
     }
     return newTask.id;
-  }, [tasks, currentTask, dayStartTime, isDayStarted, dataService, accumulatePlannedTaskTime]);
+  }, [tasks, currentTask, dataService, accumulatePlannedTaskTime]);
+
+  const startNewTask = useCallback((
+    title: string,
+    description?: string,
+    project?: string,
+    client?: string,
+    category?: string
+  ): string =>
+    beginTask({ isDayStarted, dayStartTime }, title, description, project, client, category),
+  [beginTask, isDayStarted, dayStartTime]);
 
   const updateTask = useCallback((taskId: string, updates: Partial<Task>) => {
     const updatedTasks = tasks.map(task => (task.id === taskId ? { ...task, ...updates } : task));
@@ -1583,25 +1598,24 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     }
   }, [accumulatePlannedTaskTime]);
 
-  const pullPlannedTaskToDay = useCallback((id: string) => {
-    if (!isDayStarted) {
-      toast({ title: "Start your work day first", description: "Go to the Dashboard and start your day before pulling tasks." });
-      return;
-    }
-    if (isDayStale) {
-      toast({ title: "Resolve your previous day first", description: "Your previous work day is still open. Please end or discard it." });
-      return;
-    }
+  // Shared by pull/add/start-day-and-pull. `day` is explicit so a freshly
+  // started day (not yet reflected in state) is persisted correctly.
+  // "pull" marks the planned task in_progress and links it; "add" only logs a
+  // new time entry against it (resuming an already in-progress task).
+  const startPlannedTaskInDay = useCallback((
+    id: string,
+    mode: "pull" | "add",
+    day: { isDayStarted: boolean; dayStartTime: Date | null }
+  ) => {
     const task = plannedTasksRef.current.find(t => t.id === id);
     if (!task) return;
-    const newTaskId = startNewTask(task.title, task.description, task.project, task.client, task.category);
+    const newTaskId = beginTask(day, task.title, task.description, task.project, task.client, task.category);
     const now = new Date().toISOString();
     const date = now.slice(0, 10);
     const newEntry: PlannedTaskTimeEntry = { taskId: newTaskId, duration: 0, date };
     const updated: PlannedTask = {
       ...task,
-      status: "in_progress" as PlannedTaskStatus,
-      linkedTaskId: newTaskId,
+      ...(mode === "pull" ? { status: "in_progress" as PlannedTaskStatus, linkedTaskId: newTaskId } : {}),
       timeEntries: [...task.timeEntries, newEntry],
       updatedAt: now
     };
@@ -1609,35 +1623,53 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     plannedTasksRef.current = next;
     setPlannedTasks(next);
     if (plannedLoadedRef.current) void dataServiceRef.current?.upsertPlannedTask(updated);
-    toast({ title: `Task started: ${task.title}` });
-  }, [isDayStarted, isDayStale, startNewTask]);
+    toast({ title: mode === "pull" ? `Task started: ${task.title}` : `Resumed: ${task.title}` });
+  }, [beginTask]);
+
+  const pullPlannedTaskToDay = useCallback((id: string) => {
+    if (!isDayStarted) {
+      toast({ title: "Start your work day first", description: "Start your day before pulling tasks." });
+      return;
+    }
+    if (isDayStale) {
+      toast({ title: "Resolve your previous day first", description: "Your previous work day is still open. Please end or discard it." });
+      return;
+    }
+    startPlannedTaskInDay(id, "pull", { isDayStarted, dayStartTime });
+  }, [isDayStarted, isDayStale, dayStartTime, startPlannedTaskInDay]);
 
   const addPlannedTaskToDay = useCallback((id: string) => {
     if (!isDayStarted) {
-      toast({ title: "Start your work day first", description: "Go to the Dashboard and start your day before adding tasks." });
+      toast({ title: "Start your work day first", description: "Start your day before adding tasks." });
       return;
     }
     if (isDayStale) {
       toast({ title: "Resolve your previous day first", description: "Your previous work day is still open. Please end or discard it." });
       return;
     }
-    const task = plannedTasksRef.current.find(t => t.id === id);
-    if (!task) return;
-    const newTaskId = startNewTask(task.title, task.description, task.project, task.client, task.category);
-    const now = new Date().toISOString();
-    const date = now.slice(0, 10);
-    const newEntry: PlannedTaskTimeEntry = { taskId: newTaskId, duration: 0, date };
-    const updated: PlannedTask = {
-      ...task,
-      timeEntries: [...task.timeEntries, newEntry],
-      updatedAt: now
-    };
-    const next = plannedTasksRef.current.map(t => t.id === id ? updated : t);
-    plannedTasksRef.current = next;
-    setPlannedTasks(next);
-    if (plannedLoadedRef.current) void dataServiceRef.current?.upsertPlannedTask(updated);
-    toast({ title: `Resumed: ${task.title}` });
-  }, [isDayStarted, isDayStale, startNewTask]);
+    startPlannedTaskInDay(id, "add", { isDayStarted, dayStartTime });
+  }, [isDayStarted, isDayStale, dayStartTime, startPlannedTaskInDay]);
+
+  // Starts the day at "now" (rounded like startDay) and the planned task in one
+  // step. In-progress tasks resume ("add"); everything else is pulled.
+  const startDayAndPullPlannedTask = useCallback((id: string) => {
+    if (isDayStarted) {
+      const planned = plannedTasksRef.current.find(t => t.id === id);
+      if (planned?.status === "in_progress") addPlannedTaskToDay(id);
+      else pullPlannedTaskToDay(id);
+      return;
+    }
+    if (tasks.length > 0) {
+      toast({ title: "Post or discard your previous day first", description: "Your last work day has ended but hasn't been posted yet." });
+      return;
+    }
+    const planned = plannedTasksRef.current.find(t => t.id === id);
+    if (!planned || planned.status === "done") return;
+    const roundedTime = roundToNearest15Minutes(new Date());
+    setIsDayStarted(true);
+    setDayStartTime(roundedTime);
+    startPlannedTaskInDay(id, planned.status === "in_progress" ? "add" : "pull", { isDayStarted: true, dayStartTime: roundedTime });
+  }, [isDayStarted, tasks.length, addPlannedTaskToDay, pullPlannedTaskToDay, startPlannedTaskInDay]);
 
   const importFromCSV = useCallback(async (
     csvContent: string
@@ -1712,6 +1744,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     movePlannedTask,
     pullPlannedTaskToDay,
     addPlannedTaskToDay,
+    startDayAndPullPlannedTask,
     addProject,
     updateProject,
     deleteProject,
@@ -1782,6 +1815,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     movePlannedTask,
     pullPlannedTaskToDay,
     addPlannedTaskToDay,
+    startDayAndPullPlannedTask,
     addProject,
     updateProject,
     deleteProject,
diff --git a/src/pages/Index.tsx b/src/pages/Index.tsx
index c5183f6..baf720f 100644
--- a/src/pages/Index.tsx
+++ b/src/pages/Index.tsx
@@ -4,6 +4,7 @@ import { StartDayDialog } from "@/components/StartDayDialog";
 import { StaleDayDialog } from "@/components/StaleDayDialog";
 import { TaskItem } from "@/components/TaskItem";
 import { NewTaskForm } from "@/components/NewTaskForm";
+import { PlannedTaskPicker } from "@/components/PlannedTaskPicker";
 import { Button } from "@/components/ui/button";
 import { Card, CardAction, CardContent, CardDescription, CardHeader, CardTitle } from "@/components/ui/card";
 import {
@@ -358,10 +359,12 @@ const TimeTrackerContent = () => {
                   </CardContent>
                 </Card>
 
-                {(tasks.length === 0 || showAddTaskForm) && (
+                {showAddTaskForm && (
                   <NewTaskForm onSubmit={handleNewTask} onCancel={() => setShowAddTaskForm(false)} defaultOpen={true} />
                 )}
 
+                {tasks.length === 0 && !showAddTaskForm && <PlannedTaskPicker />}
+
                 {tasks.length > 0 && (
                   <div className="space-y-3">
                     <AnimatePresence>
diff --git a/src/pages/TaskList.tsx b/src/pages/TaskList.tsx
index efc5582..28e7bc0 100644
--- a/src/pages/TaskList.tsx
+++ b/src/pages/TaskList.tsx
@@ -10,25 +10,41 @@ import {
   SheetHeader,
   SheetTitle,
 } from "@/components/ui/sheet";
-import { Plus } from "lucide-react";
+import { CirclePlay, Plus } from "lucide-react";
 import { useTimeTracking } from "@/hooks/useTimeTracking";
+import { toast } from "@/hooks/use-toast";
 
 const TaskList = () => {
   const [showNewTaskSheet, setShowNewTaskSheet] = useState(false);
-  const { plannedTasks } = useTimeTracking();
+  const { plannedTasks, isDayStarted, tasks, startDay } = useTimeTracking();
+  // An ended-but-unposted day (tasks present, not started) must be posted or
+  // discarded from the Dashboard before a new one can begin.
+  const canStartDay = !isDayStarted && tasks.length === 0;
   const pageBadge = useMemo(
     () => <Badge variant="outline">{plannedTasks.length}</Badge>,
     [plannedTasks.length]
   );
   const openNewTaskSheet = useCallback(() => setShowNewTaskSheet(true), []);
+  const handleStartDay = useCallback(() => {
+    startDay();
+    toast({ title: "Day started" });
+  }, [startDay]);
   const pageActions = useMemo(
     () => (
-      <Button onClick={openNewTaskSheet} size="sm">
-        <Plus className="w-4 h-4 mr-1" />
-        New Task
-      </Button>
+      <div className="flex items-center gap-2">
+        {canStartDay && (
+          <Button onClick={handleStartDay} size="sm" variant="outline">
+            <CirclePlay className="w-4 h-4 mr-1" />
+            Start Day
+          </Button>
+        )}
+        <Button onClick={openNewTaskSheet} size="sm">
+          <Plus className="w-4 h-4 mr-1" />
+          New Task
+        </Button>
+      </div>
     ),
-    [openNewTaskSheet]
+    [canStartDay, handleStartDay, openNewTaskSheet]
   );
   return (
     <PageLayout

From c42e3f7416779122fdee8eca46b1386d6dcd3430 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Sat, 17 Oct 2026 02:19:42 +0000
Subject: [PATCH 2/2] fix: keep day start in sync with task edits and persist
 adjusted task times

adjustTaskTime now pulls dayStartTime earlier when a task is moved before it,
and saves through saveCurrentDay like the other task mutations.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01FpA8FnKDt9kkxMjnfUU7uU
---
 CHANGELOG.md                         |  2 +
 src/contexts/TimeTracking.test.tsx   | 64 ++++++++++++++++++++++++++++
 src/contexts/TimeTrackingContext.tsx | 47 +++++++++++---------
 3 files changed, 93 insertions(+), 20 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ea0f1bd..463a118 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -57,6 +57,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Editing a current-day task's start time no longer leaves the day starting after its own first task: `adjustTaskTime` now pulls `dayStartTime` earlier when a task is moved before it (moving a task later leaves the day start alone). It also now persists the change through `saveCurrentDay` like the other task mutations, instead of only flagging unsaved changes and waiting for the next sync
+  — `src/contexts/TimeTrackingContext.tsx`, `src/contexts/TimeTracking.test.tsx`
 - Archived-day editing (`ArchiveEditDialog`, `ArchivedTaskRow`) had several accessibility gaps and unmemoized re-render/re-parse patterns. The "Restore" button no longer grabs focus via `autoFocus` when the dialog opens, letting Radix's default dialog focus behavior take over instead of landing keyboard focus on a state-changing action before the user has read anything. The day-summary and per-task edit toggles now announce their expanded/collapsed state via `aria-expanded`/`aria-controls`. The tasks table's header cells gained `scope="col"` and the table itself an accessible name tied to the day being edited. Per-task delete now requires a same-row Confirm/Cancel step instead of removing the row on a single click, matching the destructive-action pattern used elsewhere (the task isn't persisted until "Save Changes," so this doesn't need the full undo-toast machinery). On the performance side, the day/task dirty-check (`tasksChanged`) and the `handleTaskSave`/`handleTaskDelete`/toggle-expand callbacks are now memoized (`useMemo`/`useCallback`), and `ArchivedTaskRow`/`MarkdownDisplay` are wrapped in `React.memo`, so expanding one task row no longer re-renders every sibling row or re-parses unrelated markdown
   — `src/components/ArchiveEditDialog.tsx`, `src/components/ArchiveEditDialog.test.tsx`, `src/components/ArchivedTaskRow.tsx`, `src/components/ArchivedTaskRow.test.tsx`, `src/components/MarkdownDisplay.tsx`
 - `endDay` persisted the exact clock-out timestamp instead of rounding it to the nearest 15 minutes the way `startDay` already rounds the day's start time, so the archived day's `endTime` (and the last task's mirrored `endTime`) kept its raw seconds-precise value while `ArchiveEditDialog`'s Tasks table and day-summary form independently rounded the same values for display — producing a visible mismatch between the "posted"/persisted end time and what the edit dialog showed. `endDay` now rounds the effective end time at the source, so archived data and its display agree
diff --git a/src/contexts/TimeTracking.test.tsx b/src/contexts/TimeTracking.test.tsx
index 7a3e900..a17df84 100644
--- a/src/contexts/TimeTracking.test.tsx
+++ b/src/contexts/TimeTracking.test.tsx
@@ -1454,6 +1454,70 @@ describe("TimeTrackingContext", () => {
     });
   });
 
+  describe("adjustTaskTime and the day start", () => {
+    const setupDayWithTask = async () => {
+      const hook = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(hook.result.current.loading).toBe(false));
+      await act(async () => {
+        hook.result.current.startDay(new Date("2024-12-03T09:00:00Z"));
+      });
+      await act(async () => {
+        hook.result.current.startNewTask("First task");
+      });
+      await waitFor(() => expect(hook.result.current.currentTask).not.toBeNull());
+      return hook;
+    };
+
+    it("pulls the day start earlier when the first task is moved earlier", async () => {
+      const { result } = await setupDayWithTask();
+      const taskId = result.current.currentTask!.id;
+      const earlier = new Date("2024-12-03T08:00:00Z");
+
+      await act(async () => {
+        result.current.adjustTaskTime(taskId, earlier);
+      });
+
+      await waitFor(() => {
+        expect(result.current.dayStartTime?.getTime()).toBe(earlier.getTime());
+      });
+      expect(result.current.tasks[0].startTime.getTime()).toBe(earlier.getTime());
+    });
+
+    it("leaves the day start alone when the first task is moved later", async () => {
+      const { result } = await setupDayWithTask();
+      const taskId = result.current.currentTask!.id;
+      const originalDayStart = result.current.dayStartTime!.getTime();
+
+      await act(async () => {
+        result.current.adjustTaskTime(taskId, new Date("2024-12-03T10:00:00Z"));
+      });
+
+      await waitFor(() => {
+        expect(result.current.tasks[0].startTime.getTime()).toBe(
+          new Date("2024-12-03T10:00:00Z").getTime()
+        );
+      });
+      expect(result.current.dayStartTime?.getTime()).toBe(originalDayStart);
+    });
+
+    it("persists the adjusted task and day start", async () => {
+      const { result } = await setupDayWithTask();
+      const taskId = result.current.currentTask!.id;
+      const earlier = new Date("2024-12-03T08:00:00Z");
+
+      await act(async () => {
+        result.current.adjustTaskTime(taskId, earlier);
+      });
+
+      await waitFor(() => {
+        const saved = JSON.parse(localStorage.getItem("timetracker_current_day") ?? "{}");
+        expect(new Date(saved.dayStartTime).getTime()).toBe(earlier.getTime());
+        expect(new Date(saved.tasks[0].startTime).getTime()).toBe(earlier.getTime());
+        expect(new Date(saved.currentTask.startTime).getTime()).toBe(earlier.getTime());
+      });
+    });
+  });
+
   describe("addBackdatedDay", () => {
     it("adds a backdated day to the archive", async () => {
       const { result } = renderHook(() => useTimeTracking(), { wrapper });
diff --git a/src/contexts/TimeTrackingContext.tsx b/src/contexts/TimeTrackingContext.tsx
index f782ca1..bfe4c86 100644
--- a/src/contexts/TimeTrackingContext.tsx
+++ b/src/contexts/TimeTrackingContext.tsx
@@ -1399,37 +1399,44 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     const roundedStartTime = roundToNearest15Minutes(startTime);
     const roundedEndTime = endTime ? roundToNearest15Minutes(endTime) : undefined;
 
-    setTasks(prev =>
-      prev.map(task => {
-        if (task.id === taskId) {
-          const updatedTask = {
+    const updatedTasks = tasks.map(task =>
+      task.id === taskId
+        ? {
             ...task,
             startTime: roundedStartTime,
             endTime: roundedEndTime,
             duration: roundedEndTime
               ? roundedEndTime.getTime() - roundedStartTime.getTime()
               : task.duration
-          };
-          return updatedTask;
-        }
-        return task;
-      })
+          }
+        : task
     );
-
     // Update current task if it's the one being adjusted
+    const updatedCurrentTask = currentTask?.id === taskId
+      ? { ...currentTask, startTime: roundedStartTime, endTime: roundedEndTime }
+      : currentTask;
+    // A day never starts after its own first task: moving a task earlier than
+    // the day start pulls the day start with it. Moving it later leaves the
+    // day start alone, preserving any gap before the first task.
+    const updatedDayStartTime =
+      dayStartTime && roundedStartTime.getTime() < dayStartTime.getTime()
+        ? roundedStartTime
+        : dayStartTime;
+
+    setTasks(updatedTasks);
     if (currentTask?.id === taskId) {
-      setCurrentTask(prev =>
-        prev
-          ? {
-              ...prev,
-              startTime: roundedStartTime,
-              endTime: roundedEndTime
-            }
-          : null
-      );
+      setCurrentTask(updatedCurrentTask);
+    }
+    if (updatedDayStartTime !== dayStartTime) {
+      setDayStartTime(updatedDayStartTime);
     }
     setHasUnsavedChanges(true);
-  }, [currentTask]);
+    if (dataService) {
+      dataService.saveCurrentDay({ isDayStarted, dayStartTime: updatedDayStartTime, currentTask: updatedCurrentTask, tasks: updatedTasks })
+        .then(() => setLastSyncTime(new Date()))
+        .catch(error => console.error("❌ Error saving after adjusting task time:", error));
+    }
+  }, [tasks, currentTask, dayStartTime, isDayStarted, dataService]);
 
   const getTotalHoursForPeriod = useCallback((startDate: Date, endDate: Date): number =>
     calcTotalHoursForPeriod(archivedDays, startDate, endDate), [archivedDays]);