diff --git a/AGENTS.md b/AGENTS.md
index 59aa127..3e75d29 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -1,6 +1,6 @@
 # AGENTS.md - AI Assistant Codebase Guide
 
-**Last Updated:** 2026-09-18
+**Last Updated:** 2026-10-19
 **Version:** 2.8.0
 
 Timetraked is a React 18 + TypeScript time tracking PWA for freelancers and consultants, with dual storage (localStorage guest mode and optional Supabase cloud sync).
@@ -22,16 +22,16 @@ 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 (~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`)
+### Test File Inventory (~410 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 |
 |---|---|
-| `src/utils/calculationUtils.test.ts` | `getDayStats`, hours/revenue/billable per-day and per-period |
+| `src/utils/calculationUtils.test.ts` | `getDayStats`, hours/revenue/billable per-day and per-period, plus legacy negative durations being ignored |
 | `src/utils/checklistUtils.test.ts` | `parseTaskChecklist`, `toggleDescriptionChecklistItem` |
 | `src/utils/exportUtils.test.ts` | `exportToCSV`, `exportToJSON`, `generateInvoiceData`, `parseCSVImport` |
 | `src/utils/reportUtils.test.ts` | Report generation utilities |
-| `src/utils/timeUtil.test.ts` | Time formatting utilities |
-| `src/contexts/TimeTracking.test.tsx` | Full context: day/task/archive management, todos, planned tasks, project CRUD, category CRUD, `discardDay`, `adjustTaskTime`, `addBackdatedDay`, client archive/restore |
+| `src/utils/timeUtil.test.ts` | Time formatting utilities, `elapsedMs` zero floor, `isEndBeforeStart` |
+| `src/contexts/TimeTracking.test.tsx` | Full context: day/task/archive management, todos, planned tasks, project CRUD, category CRUD, `discardDay`, `adjustTaskTime` (incl. end-before-start clamp), `endDay` never producing negative durations, `addBackdatedDay`, client archive/restore |
 | `src/contexts/TimeTrackingContext.forceSync.test.tsx` | `forceSyncToDatabase` behavior |
 | `src/services/dataService.test.ts` | `LocalStorageService` save/load round-trips |
 | `src/services/supabaseService.test.ts` | Upsert-only bulk saves and single-row deletes (`saveProjects`, `deleteProject`, `saveCategories`, `deleteCategory`, `saveTodos`), plus `getCurrentDay`/`saveCurrentDay`, `getArchivedDays` task pagination past the 1000-row PostgREST cap, `checkNewSchema` schema detection, and `migrateFromLocalStorage` (no-op/no-existing-data/client-name-reconcile/error-swallow paths) |
@@ -50,8 +50,8 @@ Timetraked is a React 18 + TypeScript time tracking PWA for freelancers and cons
 | `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/ArchiveEditDialog.test.tsx` | Archive edit dialog render, task editing flow, and end-before-start validation (day form and Add Task) |
+| `src/components/ArchivedTaskRow.test.tsx` | Inline expandable archived task row editing, including end-before-start validation |
 | `src/components/dateParsing.test.ts` | Date parsing utilities |
 | `src/components/BackgroundTimerNotifier.test.tsx` | Document title/OS notification updates while a timer runs in the background |
 | `src/components/CommandPalette.test.tsx` | `Cmd/Ctrl+K` command palette actions and navigation |
@@ -172,7 +172,7 @@ export const MyComponent = () => {
 | `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/components/ArchivedTaskRow.tsx`          | Inline expandable row for editing a single task within `ArchiveEditDialog` (replaces the old `TaskEditInArchiveDialog` modal); disables Save and shows an inline alert when the end time is before the start |
 | `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 |
 | `src/components/DataRecoveryDialog.tsx`       | Settings → "Data Recovery" (guest mode only): lists backups, previews entity-count diffs against current state, restores and reloads |
@@ -186,6 +186,15 @@ export const MyComponent = () => {
 
 ---
 
+## Time Tracking Invariants
+
+- **Tracked time is never negative.** Compute durations with `elapsedMs(start, end)` from `@/utils/timeUtil` (zero-floored), never a bare `end.getTime() - start.getTime()`. Rounding one end of a span to 15 minutes can push it before the other.
+- `endDay` clamps its rounded end time to the latest of the day start, the running task's start, and the latest recorded task end.
+- `adjustTaskTime` collapses an end-before-start edit to a zero-length task; calculation and format helpers ignore or zero any negative value already in storage.
+- Archive editors (`ArchivedTaskRow`, the `ArchiveEditDialog` day form and Add Task form) reject an end before the start via `isEndBeforeStart` and `END_BEFORE_START_MESSAGE`. Equal times are allowed, since rounding can collapse a short task to zero length.
+
+---
+
 ## Client Management
 
 Clients are a managed entity (added in the client-management feature) that backs the project form's client dropdown.
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 463a118..3480e40 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -57,6 +57,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Fixed
 
+- Archive editors now reject an end time before the start time instead of silently saving a zero-length task. `ArchivedTaskRow` and the Add Task form in `ArchiveEditDialog` show an inline `role="alert"` message, set `aria-invalid`/`aria-describedby` on the end-time input, and disable Save/Add Task until corrected; the day summary form rejects it through its zod schema, and Save Changes reopens a collapsed summary editor so the error is visible. Equal start and end times remain allowed because 15-minute rounding can collapse a short task to zero length. New shared `isEndBeforeStart` and `END_BEFORE_START_MESSAGE` in `timeUtil`; `TimePicker` accepts `aria-invalid`
+  — `src/utils/timeUtil.ts`, `src/components/ArchivedTaskRow.tsx`, `src/components/ArchiveEditDialog.tsx`, `src/components/ui/scroll-time-picker.tsx`, `src/components/ArchivedTaskRow.test.tsx`, `src/components/ArchiveEditDialog.test.tsx`, `src/utils/timeUtil.test.ts`
+- Task durations and a day's end time can no longer go negative. `endDay` rounds the end time to 15 minutes while a running task's start is unrounded, so ending a day shortly after starting a task (e.g. task started 9:20, day ended 9:21 → rounded to 9:15) produced a negative task duration and an end time before the task began. `endDay` now never ends earlier than the day start, the running task's start, or the latest recorded task end. Every duration subtraction (task end, `beginTask`, `adjustTaskTime`, planned-task completion, archive task edit/add) goes through a new zero-floored `elapsedMs` helper, and `adjustTaskTime` collapses an end-before-start edit to a zero-length task. Stored negative values from earlier versions are ignored by the day/period/hours/revenue calculations and display as zero in `formatDuration`/`formatDurationLong`
+  — `src/utils/timeUtil.ts`, `src/utils/calculationUtils.ts`, `src/utils/reportUtils.ts`, `src/contexts/TimeTrackingContext.tsx`, `src/components/ArchivedTaskRow.tsx`, `src/components/ArchiveEditDialog.tsx`, `src/contexts/TimeTracking.test.tsx`, `src/utils/timeUtil.test.ts`, `src/utils/calculationUtils.test.ts`
 - 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
diff --git a/README-EXT.md b/README-EXT.md
index 75d33a8..308463d 100644
--- a/README-EXT.md
+++ b/README-EXT.md
@@ -52,7 +52,7 @@ For the main overview, see [README.md](README.md).
 
 **Ongoing:**
 
-- View archived days on the **Archive** page.
+- View archived days on the **Archive** page. When editing an archived day, task, or new task, an end time before the start time is flagged inline and Save/Add Task stays disabled until it is corrected.
 - Manage projects and rates via **Archive → Projects**.
 - Customize categories on the **Categories** page.
 - Export data via **Archive → Export**.
@@ -70,7 +70,7 @@ For the main overview, see [README.md](README.md).
    - **Description** (optional) — detailed notes with markdown support
    - **Project** (optional) — assign to a client/project
    - **Category** (optional) — categorize the work type
-3. Task duration calculates automatically.
+3. Task duration calculates automatically. Durations are never negative: ending a day snaps its end time to the nearest 15 minutes but never earlier than the running task's start, and editing a task so it ends before it starts collapses it to zero length.
 4. Create new tasks as you switch between work items.
 
 **Evening:**
@@ -473,7 +473,7 @@ src/
 │   ├── checklistUtils.ts         # GFM checklist extraction
 │   ├── exportUtils.ts            # CSV import/export
 │   ├── reportUtils.ts            # Report grouping and formatting
-│   └── timeUtil.ts               # Time formatting
+│   └── timeUtil.ts               # Time formatting, 15-minute rounding, zero-floored `elapsedMs`, end-before-start check
 ├── App.css
 ├── App.tsx
 ├── index.css
diff --git a/README.md b/README.md
index 12c18a9..1ecc5b2 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,7 @@ A Progressive Web App (PWA) for time tracking built with React, TypeScript, and
 ## Features
 
 - **Daily Time Tracking** — start/stop your workday with clear daily boundaries
-- **Task Management** — create, edit, and delete tasks with real-time duration tracking
+- **Task Management** — create, edit, and delete tasks with real-time duration tracking; tracked time is never negative, and an end time earlier than its start is rejected in the archive editors
 - **Projects & Clients** — organize work by project with per-project hourly rates; projects and clients can be archived and restored
 - **Client Management** — maintain a managed client list with address and contact details; add, edit, and archive clients (blocked while they still have active projects); pick clients from a dropdown when creating projects
 - **Revenue Tracking** — automatic earnings calculation based on hourly rates
@@ -60,7 +60,7 @@ pnpm preview             # Preview production build
 
 # Code Quality
 pnpm lint                # ESLint
-pnpm test                # Vitest unit tests (395 tests across 38 files)
+pnpm test                # Vitest unit tests (410 tests across 37 files)
 
 # PWA Screenshots
 pnpm screenshots:install   # Install Playwright (first time)
diff --git a/agents/pitfalls.md b/agents/pitfalls.md
index a7cdfaf..8acf857 100644
--- a/agents/pitfalls.md
+++ b/agents/pitfalls.md
@@ -72,6 +72,19 @@ Any utility that needs archived days must consume the context or accept
 `DayRecord[]` as a parameter. Use `dayRecordsToArchivedDays()` from
 `src/utils/reportUtils.ts` to convert to the `ArchivedDay[]` shape.
 
+### 7. Subtracting Timestamps Directly
+
+```typescript
+// ❌ WRONG — goes negative when rounding moves one end past the other
+const duration = endTime.getTime() - startTime.getTime();
+
+// ✅ CORRECT — zero-floored
+import { elapsedMs } from "@/utils/timeUtil";
+const duration = elapsedMs(startTime, endTime);
+```
+
+Time forms that take a start and an end should also reject an end before the start with `isEndBeforeStart`.
+
 ---
 
 ## Architecture Gotchas
diff --git a/src/components/ArchiveEditDialog.test.tsx b/src/components/ArchiveEditDialog.test.tsx
index 770cb18..e8a41f7 100644
--- a/src/components/ArchiveEditDialog.test.tsx
+++ b/src/components/ArchiveEditDialog.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen, within } from "@testing-library/react";
+import { render, screen, within, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { ArchiveEditDialog } from "@/components/ArchiveEditDialog";
 import { TooltipProvider } from "@/components/ui/tooltip";
@@ -185,4 +185,70 @@ describe("ArchiveEditDialog", () => {
     expect(lastTask.endTime.getHours()).toBe(17);
     expect(lastTask.endTime.getMinutes()).toBe(45);
   });
+
+  it("rejects a day end time before the start time and keeps the editor open with the error", async () => {
+    const user = userEvent.setup();
+    renderDialog({ day: buildDay(), isOpen: true, onClose: vi.fn() });
+
+    await user.click(screen.getByRole("button", { name: "Edit day summary" }));
+    fireEvent.change(screen.getByLabelText("Day end time"), {
+      target: { value: "08:00" },
+    });
+    await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+    expect(
+      await screen.findByText("End time must be after start time.")
+    ).toBeInTheDocument();
+    expect(updateArchivedDay).not.toHaveBeenCalled();
+  });
+
+  it("opens the day-summary editor to show the error when a collapsed day is invalid", async () => {
+    const user = userEvent.setup();
+    const day = buildDay();
+    // Legacy bad data: the day ends before it starts.
+    day.endTime = new Date(2026, 5, 15, 8, 0, 0);
+    renderDialog({ day, isOpen: true, onClose: vi.fn() });
+
+    // Stage an unrelated task edit so Save Changes is enabled.
+    const taskTwoRow = screen.getByText("Task Two").closest("tr")!;
+    await user.click(within(taskTwoRow).getByRole("button", { name: "Edit task" }));
+    const titleInput = screen.getByLabelText(/Task Title/);
+    await user.clear(titleInput);
+    await user.type(titleInput, "Task Two Updated");
+    await user.click(screen.getByRole("button", { name: "Save" }));
+
+    expect(screen.queryByLabelText("Day end time")).not.toBeInTheDocument();
+    await user.click(screen.getByRole("button", { name: /save changes/i }));
+
+    expect(await screen.findByLabelText("Day end time")).toBeInTheDocument();
+    expect(
+      screen.getByText("End time must be after start time.")
+    ).toBeInTheDocument();
+    expect(updateArchivedDay).not.toHaveBeenCalled();
+  });
+
+  it("disables Add Task and shows an error when the new task ends before it starts", async () => {
+    const user = userEvent.setup();
+    renderDialog({ day: buildDay(), isOpen: true, onClose: vi.fn() });
+
+    await user.click(screen.getByRole("button", { name: "Add Task" }));
+    await user.type(screen.getByLabelText(/Task Title/), "Late task");
+    fireEvent.change(screen.getByLabelText("Task start time"), {
+      target: { value: "14:00" },
+    });
+    fireEvent.change(screen.getByLabelText("Task end time"), {
+      target: { value: "13:00" },
+    });
+
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "End time must be after start time."
+    );
+    expect(screen.getByRole("button", { name: "Add Task" })).toBeDisabled();
+
+    fireEvent.change(screen.getByLabelText("Task end time"), {
+      target: { value: "15:00" },
+    });
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Add Task" })).toBeEnabled();
+  });
 });
diff --git a/src/components/ArchiveEditDialog.tsx b/src/components/ArchiveEditDialog.tsx
index 27df56b..f6f78a3 100644
--- a/src/components/ArchiveEditDialog.tsx
+++ b/src/components/ArchiveEditDialog.tsx
@@ -63,6 +63,9 @@ import {
   X,
 } from "lucide-react";
 import {
+  elapsedMs,
+  END_BEFORE_START_MESSAGE,
+  isEndBeforeStart,
   formatDuration,
   formatDate,
   roundToNearest15Minutes,
@@ -107,6 +110,9 @@ const dayFormSchema = z.object({
     .string()
     .regex(/^([01]\d|2[0-3]):[0-5]\d$/, "Enter a valid time"),
   notes: z.string().optional(),
+}).refine((values) => !isEndBeforeStart(values.startTime, values.endTime), {
+  message: END_BEFORE_START_MESSAGE,
+  path: ["endTime"],
 });
 
 type DayFormValues = z.infer<typeof dayFormSchema>;
@@ -357,6 +363,8 @@ export const ArchiveEditDialog: React.FC<ArchiveEditDialogProps> = ({
     setExpandedTaskId((cur) => (cur === id ? null : id));
   }, []);
 
+  const newTaskEndBeforeStart = isEndBeforeStart(newTaskTimes.startTime, newTaskTimes.endTime);
+
   const handleAddTask = () => {
     const selectedProject =
       newTaskData.project !== "none"
@@ -383,7 +391,7 @@ export const ArchiveEditDialog: React.FC<ArchiveEditDialogProps> = ({
       startTime,
       endTime,
       duration: endTime
-        ? endTime.getTime() - startTime.getTime()
+        ? elapsedMs(startTime, endTime)
         : undefined,
     };
 
@@ -461,7 +469,10 @@ export const ArchiveEditDialog: React.FC<ArchiveEditDialogProps> = ({
               Cancel
             </Button>
             <Button
-              onClick={dayForm.handleSubmit(handleSaveDay)}
+              onClick={dayForm.handleSubmit(handleSaveDay, () =>
+                // Surface the error message even if the summary editor is collapsed
+                setIsSummaryEditing(true),
+              )}
               size="sm"
               disabled={!hasChanges || isSaving}
             >
@@ -865,7 +876,14 @@ export const ArchiveEditDialog: React.FC<ArchiveEditDialogProps> = ({
                                     setNewTaskTimes((prev) => ({ ...prev, endTime: value }))
                                   }
                                   aria-label="Task end time"
+                                  aria-invalid={newTaskEndBeforeStart}
+                                  aria-describedby={newTaskEndBeforeStart ? "new-task-end-error" : undefined}
                                 />
+                                {newTaskEndBeforeStart && (
+                                  <p id="new-task-end-error" role="alert" className="mt-1 text-sm text-destructive">
+                                    {END_BEFORE_START_MESSAGE}
+                                  </p>
+                                )}
                               </div>
                             </div>
 
@@ -879,7 +897,7 @@ export const ArchiveEditDialog: React.FC<ArchiveEditDialogProps> = ({
                               </Button>
                               <Button
                                 onClick={handleAddTask}
-                                disabled={!newTaskData.title.trim() || isSaving}
+                                disabled={!newTaskData.title.trim() || newTaskEndBeforeStart || isSaving}
                                 variant="default"
                                 size="sm"
                               >
diff --git a/src/components/ArchivedTaskRow.test.tsx b/src/components/ArchivedTaskRow.test.tsx
index 580bfda..cbf0680 100644
--- a/src/components/ArchivedTaskRow.test.tsx
+++ b/src/components/ArchivedTaskRow.test.tsx
@@ -1,5 +1,5 @@
 import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render, screen } from "@testing-library/react";
+import { render, screen, fireEvent } from "@testing-library/react";
 import userEvent from "@testing-library/user-event";
 import { TooltipProvider } from "@/components/ui/tooltip";
 import { Table, TableBody } from "@/components/ui/table";
@@ -295,4 +295,59 @@ describe("ArchivedTaskRow", () => {
 
     expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
   });
+
+  it("blocks saving and announces an error when the end time is before the start time", () => {
+    const onSave = vi.fn();
+    renderRow({
+      task: baseTask,
+      isExpanded: true,
+      onToggleExpand: vi.fn(),
+      onSave,
+      onDelete: vi.fn(),
+      categories,
+      projects,
+    });
+
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+
+    // Pre-filled 09:00 to 10:45; move the end before the start.
+    fireEvent.change(screen.getByLabelText("Task end time"), {
+      target: { value: "08:00" },
+    });
+
+    expect(screen.getByRole("alert")).toHaveTextContent(
+      "End time must be after start time."
+    );
+    expect(screen.getByLabelText("Task end time")).toHaveAttribute(
+      "aria-invalid",
+      "true"
+    );
+    expect(screen.getByRole("button", { name: "Save" })).toBeDisabled();
+
+    // Correcting the end time clears the error and re-enables Save.
+    fireEvent.change(screen.getByLabelText("Task end time"), {
+      target: { value: "11:00" },
+    });
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Save" })).toBeEnabled();
+  });
+
+  it("allows saving when the rounded start and end times are equal", () => {
+    renderRow({
+      task: baseTask,
+      isExpanded: true,
+      onToggleExpand: vi.fn(),
+      onSave: vi.fn(),
+      onDelete: vi.fn(),
+      categories,
+      projects,
+    });
+
+    fireEvent.change(screen.getByLabelText("Task end time"), {
+      target: { value: "09:00" },
+    });
+
+    expect(screen.queryByRole("alert")).not.toBeInTheDocument();
+    expect(screen.getByRole("button", { name: "Save" })).toBeEnabled();
+  });
 });
diff --git a/src/components/ArchivedTaskRow.tsx b/src/components/ArchivedTaskRow.tsx
index 322a9c4..876e624 100644
--- a/src/components/ArchivedTaskRow.tsx
+++ b/src/components/ArchivedTaskRow.tsx
@@ -14,7 +14,13 @@ import {
   TooltipTrigger,
 } from "@/components/ui/tooltip";
 import { Edit, Trash2, X } from "lucide-react";
-import { formatDuration, formatTimeForInput } from "@/utils/timeUtil";
+import {
+  elapsedMs,
+  END_BEFORE_START_MESSAGE,
+  formatDuration,
+  formatTimeForInput,
+  isEndBeforeStart,
+} from "@/utils/timeUtil";
 import { Task, Project } from "@/contexts/TimeTrackingContext";
 import { TaskCategory } from "@/config/categories";
 
@@ -92,6 +98,8 @@ export const ArchivedTaskRow: React.FC<ArchivedTaskRowProps> = React.memo(({
   }, [task, projects, isExpanded]);
 
   const category = categories.find((c) => c.id === task.category);
+  const endBeforeStart = isEndBeforeStart(timeData.startTime, timeData.endTime);
+  const endErrorId = `archive-task-end-error-${task.id}`;
 
   const handleSave = () => {
     const selectedProject =
@@ -118,7 +126,7 @@ export const ArchivedTaskRow: React.FC<ArchivedTaskRowProps> = React.memo(({
       startTime: newStartTime,
       endTime: newEndTime,
       duration: newEndTime
-        ? newEndTime.getTime() - newStartTime.getTime()
+        ? elapsedMs(newStartTime, newEndTime)
         : task.duration,
     };
 
@@ -371,7 +379,14 @@ export const ArchivedTaskRow: React.FC<ArchivedTaskRowProps> = React.memo(({
                       setTimeData((prev) => ({ ...prev, endTime: value }))
                     }
                     aria-label="Task end time"
+                    aria-invalid={endBeforeStart}
+                    aria-describedby={endBeforeStart ? endErrorId : undefined}
                   />
+                  {endBeforeStart && (
+                    <p id={endErrorId} role="alert" className="mt-1 text-sm text-destructive">
+                      {END_BEFORE_START_MESSAGE}
+                    </p>
+                  )}
                 </div>
               </div>
 
@@ -385,7 +400,7 @@ export const ArchivedTaskRow: React.FC<ArchivedTaskRowProps> = React.memo(({
                 </Button>
                 <Button
                   onClick={handleSave}
-                  disabled={!formData.title.trim()}
+                  disabled={!formData.title.trim() || endBeforeStart}
                   variant="default"
                   size="sm"
                 >
diff --git a/src/components/ui/scroll-time-picker.tsx b/src/components/ui/scroll-time-picker.tsx
index 6daae7a..361126c 100644
--- a/src/components/ui/scroll-time-picker.tsx
+++ b/src/components/ui/scroll-time-picker.tsx
@@ -9,6 +9,7 @@ interface TimePickerProps {
   id?: string;
   'aria-label'?: string;
   'aria-describedby'?: string;
+  'aria-invalid'?: boolean;
 }
 
 /**
diff --git a/src/contexts/TimeTracking.test.tsx b/src/contexts/TimeTracking.test.tsx
index a17df84..aae0206 100644
--- a/src/contexts/TimeTracking.test.tsx
+++ b/src/contexts/TimeTracking.test.tsx
@@ -113,6 +113,47 @@ describe("TimeTrackingContext", () => {
 			);
 		});
 
+		it("never records a negative duration or an end time before the running task's start when rounding pulls the end back", async () => {
+			try {
+				const { result } = renderHook(() => useTimeTracking(), { wrapper });
+				await waitFor(() => expect(result.current.loading).toBe(false));
+
+				vi.setSystemTime(new Date(2024, 11, 3, 9, 0, 0));
+				await act(async () => {
+					result.current.startDay(new Date(2024, 11, 3, 9, 0, 0));
+				});
+				await act(async () => {
+					result.current.startNewTask("First");
+				});
+
+				// The second task starts at an unrounded 09:20:30...
+				vi.setSystemTime(new Date(2024, 11, 3, 9, 20, 30));
+				await act(async () => {
+					result.current.startNewTask("Second");
+				});
+
+				// ...and the day ends at 09:21, which rounds back to 09:15 — before it began.
+				await act(async () => {
+					result.current.endDay(new Date(2024, 11, 3, 9, 21, 0));
+				});
+				await act(async () => {
+					result.current.postDay();
+				});
+				await waitFor(() => expect(result.current.archivedDays.length).toBe(1));
+
+				const archived = result.current.archivedDays[0];
+				archived.tasks.forEach(task => {
+					expect(task.duration ?? 0).toBeGreaterThanOrEqual(0);
+					expect(task.endTime!.getTime()).toBeGreaterThanOrEqual(task.startTime.getTime());
+				});
+				expect(archived.totalDuration).toBeGreaterThanOrEqual(0);
+				expect(archived.endTime.getTime()).toBeGreaterThanOrEqual(archived.tasks[1].startTime.getTime());
+			} finally {
+				// Restore the global mock date from src/test-setup.ts.
+				vi.setSystemTime(new Date("2024-12-03T10:00:00.000Z"));
+			}
+		});
+
 		it("should calculate total day duration correctly", async () => {
 			const { result } = renderHook(() => useTimeTracking(), { wrapper });
 
@@ -1454,6 +1495,33 @@ describe("TimeTrackingContext", () => {
     });
   });
 
+  describe("adjustTaskTime with an end before the start", () => {
+    it("collapses to a zero-length task instead of a negative duration", async () => {
+      const { result } = renderHook(() => useTimeTracking(), { wrapper });
+      await waitFor(() => expect(result.current.loading).toBe(false));
+
+      await act(async () => {
+        result.current.startDay(new Date("2024-12-03T09:00:00Z"));
+        result.current.startNewTask("Backwards task");
+      });
+      const taskId = result.current.currentTask!.id;
+
+      await act(async () => {
+        result.current.adjustTaskTime(
+          taskId,
+          new Date("2024-12-03T10:00:00Z"),
+          new Date("2024-12-03T09:00:00Z")
+        );
+      });
+
+      await waitFor(() => {
+        const task = result.current.tasks.find(t => t.id === taskId);
+        expect(task?.duration).toBe(0);
+        expect(task?.endTime?.getTime()).toBe(task?.startTime.getTime());
+      });
+    });
+  });
+
   describe("adjustTaskTime and the day start", () => {
     const setupDayWithTask = async () => {
       const hook = renderHook(() => useTimeTracking(), { wrapper });
diff --git a/src/contexts/TimeTrackingContext.tsx b/src/contexts/TimeTrackingContext.tsx
index bfe4c86..5236dc2 100644
--- a/src/contexts/TimeTrackingContext.tsx
+++ b/src/contexts/TimeTrackingContext.tsx
@@ -28,7 +28,7 @@ import {
   parseCSVImport
 } from '@/utils/exportUtils';
 import { parseTaskChecklist } from '@/utils/checklistUtils';
-import { roundToNearest15Minutes, formatDate } from '@/utils/timeUtil';
+import { roundToNearest15Minutes, formatDate, elapsedMs } from '@/utils/timeUtil';
 import { SCHEMA_VERSION } from '@/services/localStorageService';
 import { useElectronBackup } from '@/hooks/useElectronBackup';
 
@@ -758,10 +758,21 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     // that displays it (ArchiveEditDialog, TaskEditDialog, etc.) rounds to
     // the nearest 15 minutes, producing a mismatch between what's shown
     // and what was actually persisted.
-    const effectiveEndTime = roundToNearest15Minutes(endDateTime ?? new Date());
+    //
+    // Rounding can land before the running task's (unrounded) start or the
+    // day start, which would yield a negative duration — never end earlier
+    // than the latest moment already recorded.
+    const roundedEndTime = roundToNearest15Minutes(endDateTime ?? new Date());
+    const earliestEndMs = Math.max(
+      dayStartTime?.getTime() ?? 0,
+      currentTask?.startTime.getTime() ?? 0,
+      ...tasks.map(t => t.endTime?.getTime() ?? 0)
+    );
+    const effectiveEndTime =
+      roundedEndTime.getTime() < earliestEndMs ? new Date(earliestEndMs) : roundedEndTime;
     let finalTasks = tasks;
     if (currentTask) {
-      const duration = effectiveEndTime.getTime() - currentTask.startTime.getTime();
+      const duration = elapsedMs(currentTask.startTime, effectiveEndTime);
       const endedTask = {
         ...currentTask,
         endTime: effectiveEndTime,
@@ -819,7 +830,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
     // End current task if exists and compute the updated task list synchronously
     let baseTasks = tasks;
     if (currentTask) {
-      const duration = now.getTime() - currentTask.startTime.getTime();
+      const duration = elapsedMs(currentTask.startTime, now);
       const endedTask = {
         ...currentTask,
         endTime: now,
@@ -1397,7 +1408,11 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
   // Time adjustment function (rounds to nearest 15 minutes)
   const adjustTaskTime = useCallback((taskId: string, startTime: Date, endTime?: Date) => {
     const roundedStartTime = roundToNearest15Minutes(startTime);
-    const roundedEndTime = endTime ? roundToNearest15Minutes(endTime) : undefined;
+    // An end time before the start (typed by the user, or produced by rounding)
+    // collapses to a zero-length task rather than a negative one.
+    const roundedEndTime = endTime
+      ? new Date(Math.max(roundToNearest15Minutes(endTime).getTime(), roundedStartTime.getTime()))
+      : undefined;
 
     const updatedTasks = tasks.map(task =>
       task.id === taskId
@@ -1406,7 +1421,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
             startTime: roundedStartTime,
             endTime: roundedEndTime,
             duration: roundedEndTime
-              ? roundedEndTime.getTime() - roundedStartTime.getTime()
+              ? elapsedMs(roundedStartTime, roundedEndTime)
               : task.duration
           }
         : task
@@ -1576,7 +1591,7 @@ export const TimeTrackingProvider: React.FC<{ children: React.ReactNode }> = ({
         const isLinked = plannedTask?.timeEntries.some(e => e.taskId === activeTask.id);
         if (isLinked) {
           const endTime = new Date();
-          const duration = endTime.getTime() - activeTask.startTime.getTime();
+          const duration = elapsedMs(activeTask.startTime, endTime);
           const endedTask = { ...activeTask, endTime, duration };
           const updatedTasks = latestStateRef.current.tasks.map(t =>
             t.id === activeTask.id ? endedTask : t
diff --git a/src/utils/calculationUtils.test.ts b/src/utils/calculationUtils.test.ts
index 990b29f..44ae999 100644
--- a/src/utils/calculationUtils.test.ts
+++ b/src/utils/calculationUtils.test.ts
@@ -6,7 +6,9 @@ import {
   getBillableHoursForDay,
   getNonBillableHoursForDay,
   getTotalHoursForPeriod,
-  getRevenueForPeriod
+  getRevenueForPeriod,
+  getCurrentTaskDuration,
+  getTotalDayDuration
 } from "@/utils/calculationUtils";
 import type { DayRecord, Project } from "@/contexts/TimeTrackingContext";
 import type { TaskCategory } from "@/config/categories";
@@ -63,6 +65,42 @@ function makeDay(overrides: Partial<DayRecord> = {}): DayRecord {
 }
 
 describe("calculationUtils", () => {
+  describe("negative durations", () => {
+    const negativeTask = {
+      id: "neg",
+      title: "Legacy negative",
+      startTime: new Date("2024-12-01T09:20:00Z"),
+      endTime: new Date("2024-12-01T09:15:00Z"),
+      duration: -300_000,
+      project: "Project A",
+      client: "Client X",
+      category: "cat1"
+    };
+
+    it("getCurrentTaskDuration never goes negative when the task starts after now", () => {
+      const task = { id: "t", title: "T", startTime: new Date("2024-12-01T09:15:00Z") };
+      expect(getCurrentTaskDuration(task, new Date("2024-12-01T09:00:00Z"))).toBe(0);
+    });
+
+    it("getTotalDayDuration ignores stored negative durations", () => {
+      expect(getTotalDayDuration([negativeTask], null, new Date())).toBe(0);
+    });
+
+    it("getHoursWorkedForDay and getDayStats ignore stored negative durations", () => {
+      const day = makeDay({ tasks: [negativeTask] });
+      expect(getHoursWorkedForDay(day)).toBe(0);
+      const stats = getDayStats(day, new Map([[project.name, project]]), new Map([[category.id, category]]));
+      expect(stats).toEqual({ hoursWorked: 0, billableHours: 0, nonBillableHours: 0, revenue: 0 });
+    });
+
+    it("getTotalHoursForPeriod ignores a stored negative day total", () => {
+      const days = [makeDay({ totalDuration: -300_000 })];
+      expect(
+        getTotalHoursForPeriod(days, new Date("2024-11-01"), new Date("2024-12-31"))
+      ).toBe(0);
+    });
+  });
+
   describe("getHoursWorkedForDay", () => {
     it("sums task durations and converts to hours", () => {
       expect(getHoursWorkedForDay(makeDay())).toBe(1);
diff --git a/src/utils/calculationUtils.ts b/src/utils/calculationUtils.ts
index db453ff..7cba420 100644
--- a/src/utils/calculationUtils.ts
+++ b/src/utils/calculationUtils.ts
@@ -1,5 +1,6 @@
 import { Task, DayRecord, Project } from "@/contexts/TimeTrackingContext";
 import { TaskCategory } from "@/config/categories";
+import { elapsedMs } from "@/utils/timeUtil";
 
 /**
  * Returns true if a task is billable based on its project and category settings.
@@ -40,7 +41,7 @@ export function getDayStats(
 	let revenue = 0;
 
 	day.tasks.forEach(task => {
-		if (!task.duration) return;
+		if (!task.duration || task.duration < 0) return;
 		totalMs += task.duration;
 		if (task.project && task.category) {
 			if (isTaskBillable(task, projectMap, categoryMap)) {
@@ -70,7 +71,7 @@ export function getDayStats(
  */
 export function getCurrentTaskDuration(currentTask: Task | null, now: Date): number {
 	if (!currentTask) return 0;
-	return now.getTime() - currentTask.startTime.getTime();
+	return elapsedMs(currentTask.startTime, now);
 }
 
 /**
@@ -79,7 +80,7 @@ export function getCurrentTaskDuration(currentTask: Task | null, now: Date): num
  */
 export function getTotalDayDuration(tasks: Task[], currentTask: Task | null, now: Date): number {
 	const completedTasksDuration = tasks
-		.filter(task => task.duration)
+		.filter(task => task.duration && task.duration > 0)
 		.reduce((total, task) => total + (task.duration || 0), 0);
 
 	return completedTasksDuration + getCurrentTaskDuration(currentTask, now);
@@ -88,7 +89,7 @@ export function getTotalDayDuration(tasks: Task[], currentTask: Task | null, now
 export function getHoursWorkedForDay(day: DayRecord): number {
 	let totalTaskDuration = 0;
 	day.tasks.forEach(task => {
-		if (task.duration) totalTaskDuration += task.duration;
+		if (task.duration && task.duration > 0) totalTaskDuration += task.duration;
 	});
 	return Math.round((totalTaskDuration / (1000 * 60 * 60)) * 100) / 100;
 }
@@ -167,7 +168,7 @@ export function getTotalHoursForPeriod(
 		return dayDate >= startDate && dayDate <= endDate;
 	});
 
-	const totalMs = filteredDays.reduce((total, day) => total + day.totalDuration, 0);
+	const totalMs = filteredDays.reduce((total, day) => total + Math.max(0, day.totalDuration), 0);
 	return Math.round((totalMs / (1000 * 60 * 60)) * 100) / 100;
 }
 
diff --git a/src/utils/reportUtils.ts b/src/utils/reportUtils.ts
index 7e4a5ad..af91711 100644
--- a/src/utils/reportUtils.ts
+++ b/src/utils/reportUtils.ts
@@ -232,7 +232,7 @@ function formatWeekLabel(start: Date, end: Date): string {
 
 /** Converts milliseconds to a human-readable "Xh Ym" string. */
 export function formatDuration(ms: number): string {
-  const totalMinutes = Math.round(ms / 60000);
+  const totalMinutes = Math.round(Math.max(0, ms) / 60000);
   const hours = Math.floor(totalMinutes / 60);
   const minutes = totalMinutes % 60;
   if (hours === 0) return `${minutes}m`;
diff --git a/src/utils/timeUtil.test.ts b/src/utils/timeUtil.test.ts
index 725fec2..2119fe3 100644
--- a/src/utils/timeUtil.test.ts
+++ b/src/utils/timeUtil.test.ts
@@ -1,6 +1,9 @@
 import { describe, it, expect } from "vitest";
 import {
+  elapsedMs,
+  isEndBeforeStart,
   formatDuration,
+  formatDurationLong,
   formatDate,
   formatTime,
   formatHoursDecimal,
@@ -32,6 +35,11 @@ describe("timeUtil", () => {
 			expect(formatDuration(-3600000)).toBe("0:00");
 		});
 
+		it("should treat sub-hour negative durations as zero", () => {
+			expect(formatDuration(-1800000)).toBe("0:00");
+			expect(formatDurationLong(-1800000)).toBe("0 minutes");
+		});
+
 		it("should round partial minutes correctly", () => {
 			// 1 hour 30 minutes 30 seconds
 			expect(formatDuration(5430000)).toBe("1:30");
@@ -41,6 +49,36 @@ describe("timeUtil", () => {
 		});
 	});
 
+	describe("elapsedMs", () => {
+		it("returns the span between two moments", () => {
+			expect(
+				elapsedMs(new Date("2024-12-03T09:00:00Z"), new Date("2024-12-03T10:30:00Z"))
+			).toBe(5_400_000);
+		});
+
+		it("floors at zero when the end precedes the start", () => {
+			expect(
+				elapsedMs(new Date("2024-12-03T09:20:00Z"), new Date("2024-12-03T09:15:00Z"))
+			).toBe(0);
+		});
+	});
+
+	describe("isEndBeforeStart", () => {
+		it("flags an end strictly before the start", () => {
+			expect(isEndBeforeStart("14:00", "13:45")).toBe(true);
+		});
+
+		it("allows an equal or later end", () => {
+			expect(isEndBeforeStart("09:00", "09:00")).toBe(false);
+			expect(isEndBeforeStart("09:00", "17:30")).toBe(false);
+		});
+
+		it("ignores an unset start or end", () => {
+			expect(isEndBeforeStart("", "08:00")).toBe(false);
+			expect(isEndBeforeStart("09:00", "")).toBe(false);
+		});
+	});
+
 	describe("formatHoursDecimal", () => {
 		it("should convert milliseconds to decimal hours", () => {
 			// 1 hour = 3,600,000 ms
diff --git a/src/utils/timeUtil.ts b/src/utils/timeUtil.ts
index d8fa183..907fa18 100644
--- a/src/utils/timeUtil.ts
+++ b/src/utils/timeUtil.ts
@@ -1,5 +1,24 @@
+/**
+ * Elapsed milliseconds between two moments, floored at zero. Rounding one end
+ * of a span (e.g. snapping a day's end time to 15 minutes) can push it before
+ * the other, and tracked time is never negative.
+ */
+export const elapsedMs = (start: Date, end: Date): number =>
+  Math.max(0, end.getTime() - start.getTime());
+
+export const END_BEFORE_START_MESSAGE = "End time must be after start time.";
+
+/**
+ * True when both "HH:MM" (zero-padded, 24-hour) values are set and the end
+ * falls strictly before the start. An equal pair is allowed: rounding to 15
+ * minutes can collapse a short task to zero length, and that shouldn't block
+ * saving an unrelated edit.
+ */
+export const isEndBeforeStart = (start: string, end: string): boolean =>
+  Boolean(start) && Boolean(end) && end < start;
+
 export const formatDuration = (milliseconds: number): string => {
-  const totalSeconds = Math.floor(milliseconds / 1000);
+  const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1000);
   const hours = Math.floor(totalSeconds / 3600);
   const minutes = Math.floor((totalSeconds % 3600) / 60);
 
@@ -11,7 +30,7 @@ export const formatDuration = (milliseconds: number): string => {
 };
 
 export const formatDurationLong = (milliseconds: number): string => {
-  const totalSeconds = Math.floor(milliseconds / 1000);
+  const totalSeconds = Math.floor(Math.max(0, milliseconds) / 1000);
   const hours = Math.floor(totalSeconds / 3600);
   const minutes = Math.floor((totalSeconds % 3600) / 60);