diff --git a/TODO.md b/TODO.md
index 610834d..df78e2e 100644
--- a/TODO.md
+++ b/TODO.md
@@ -180,7 +180,11 @@ Work Log decisions:
 - Work logs are persisted to SQLite with creation timestamps.
 - Work logs display the latest seven local calendar days, grouped by day.
 - Work logs are displayed newest first within each day.
-- `j` / `k` and `ArrowDown` / `ArrowUp`: move the selected Work Log entry when the Log section is active.
+- `j` / `k` and `ArrowDown` / `ArrowUp`: move the selected Work Log row when the Log section is active.
+- `gg` / `G`: move the selected Work Log row to the first or last visible row when the Log section is active.
+- Empty `No log` day rows are selectable navigation targets, but cannot be edited with `e`.
+- When navigating upward to the first row in a Work Log day group, scrolling keeps that day header visible.
+- When the first or last visible Work Log row is selected, the Log list scrolls fully to the top or bottom.
 - `e`: edit the selected Work Log entry when the Log section is active.
 - Activating the Log section focuses the Work Log list and selects the latest log when there is no valid current selection.
 - When a new Work Log is added, selection moves to it only if the latest log was selected; older selected logs stay selected.
diff --git a/src/lib/components/KeyboardShortcutsDialog.svelte b/src/lib/components/KeyboardShortcutsDialog.svelte
index 52335c1..6c8db23 100644
--- a/src/lib/components/KeyboardShortcutsDialog.svelte
+++ b/src/lib/components/KeyboardShortcutsDialog.svelte
@@ -116,6 +116,11 @@
           ],
           separator: "or",
         },
+        {
+          action: "Move to First or Last Log",
+          keys: [{ value: "gg" }, { value: "G" }],
+          separator: "or",
+        },
       ],
     },
   ];
@@ -141,6 +146,14 @@
       onClose();
     }
   }
+
+  function separatorAfterIndex(shortcut: ShortcutItem) {
+    if (!shortcut.separator) {
+      return -1;
+    }
+
+    return Math.ceil(shortcut.keys.length / 2) - 1;
+  }
 </script>
 
 <dialog
@@ -188,31 +201,18 @@
                   {/if}
                 </span>
                 <span class="shortcut-keys">
-                  {#if shortcut.separator}
-                    {#each shortcut.keys.slice(0, 2) as key (key.value)}
-                      <KeyboardKey
-                        value={key.value}
-                        label={key.label}
-                        size="compact"
-                      />
-                    {/each}
-                    <span class="shortcut-separator">{shortcut.separator}</span>
-                    {#each shortcut.keys.slice(2) as key (key.value)}
-                      <KeyboardKey
-                        value={key.value}
-                        label={key.label}
-                        size="compact"
-                      />
-                    {/each}
-                  {:else}
-                    {#each shortcut.keys as key (key.value)}
-                      <KeyboardKey
-                        value={key.value}
-                        label={key.label}
-                        size="compact"
-                      />
-                    {/each}
-                  {/if}
+                  {#each shortcut.keys as key, keyIndex (key.value)}
+                    <KeyboardKey
+                      value={key.value}
+                      label={key.label}
+                      size="compact"
+                    />
+                    {#if shortcut.separator && keyIndex === separatorAfterIndex(shortcut)}
+                      <span class="shortcut-separator">
+                        {shortcut.separator}
+                      </span>
+                    {/if}
+                  {/each}
                 </span>
               </div>
             {/each}
diff --git a/src/lib/components/WorkLogSection.svelte b/src/lib/components/WorkLogSection.svelte
index 0eb1377..6691d2d 100644
--- a/src/lib/components/WorkLogSection.svelte
+++ b/src/lib/components/WorkLogSection.svelte
@@ -12,13 +12,21 @@
   import { linkifyWorkLogBody } from "$lib/work-log/linkify";
   import {
     buildRecentWorkLogGroups,
+    buildWorkLogSelectableItems,
     moveWorkLogSelection,
+    selectWorkLogBoundary,
+    workLogSelectionForDate,
+    workLogSelectionKey,
+    workLogSelectionsEqual,
+    type WorkLogSelection,
   } from "$lib/work-log/ui";
 
   type WorkLogCommand =
     | "focusPreferred"
     | "moveDown"
     | "moveUp"
+    | "moveFirst"
+    | "moveLast"
     | "editSelected";
 
   type WorkLogCommandRequest = {
@@ -54,13 +62,14 @@
   let workLogs = $state<WorkLog[]>([]);
   let workLogError = $state<string | null>(null);
   let isLoadingWorkLogs = $state(true);
-  let selectedWorkLogId = $state<number | null>(null);
+  let selectedWorkLogItem = $state<WorkLogSelection | null>(null);
   let workLogListElement = $state<HTMLOListElement>();
   let relativeTimeNowMs = $state(Date.now());
   let lastCommandRequestId = 0;
   let unlistenWorkLogCreated: UnlistenFn | undefined;
   let unlistenWorkLogUpdated: UnlistenFn | undefined;
   let relativeTimeInterval: ReturnType<typeof setInterval> | undefined;
+  let keepSelectedDateHeaderVisible = false;
   const visibleWorkLogGroups = $derived(
     buildRecentWorkLogGroups(
       workLogs,
@@ -68,6 +77,12 @@
       RECENT_WORK_LOG_DAY_COUNT,
     ),
   );
+  const visibleWorkLogItems = $derived(
+    buildWorkLogSelectableItems(visibleWorkLogGroups),
+  );
+  const selectedWorkLogKey = $derived(
+    selectedWorkLogItem ? workLogSelectionKey(selectedWorkLogItem) : null,
+  );
   const lastWorkLog = $derived(workLogs[0] ?? null);
   const lastLogLabel = $derived(
     formatLastLogLabel(lastWorkLog, relativeTimeNowMs),
@@ -125,6 +140,12 @@
       case "moveUp":
         moveSelection(-1);
         break;
+      case "moveFirst":
+        moveSelectionToBoundary("first");
+        break;
+      case "moveLast":
+        moveSelectionToBoundary("last");
+        break;
       case "editSelected":
         editSelectedWorkLog();
         break;
@@ -132,7 +153,7 @@
   });
 
   $effect(() => {
-    if (!active || selectedWorkLogId === null) {
+    if (!active || !selectedWorkLogItem) {
       return;
     }
 
@@ -147,7 +168,7 @@
       workLogs = (await listWorkLogs(oldestVisibleDayStartMs())).sort(
         compareWorkLogs,
       );
-      ensureSelectedWorkLog();
+      ensureSelectedWorkLogItem();
     } catch (error) {
       workLogError = errorMessage(error);
     } finally {
@@ -157,7 +178,7 @@
 
   async function focusList() {
     onActivate();
-    ensureSelectedWorkLog();
+    ensureSelectedWorkLogItem();
     await tick();
     workLogListElement?.focus({ preventScroll: true });
     await scrollSelectedWorkLogIntoView();
@@ -185,13 +206,19 @@
     }
 
     const shouldSelectCreatedWorkLog =
-      selectedWorkLogId === null || selectedWorkLogId === lastWorkLog?.id;
+      selectedWorkLogItem === null ||
+      (selectedWorkLogItem.kind === "log" &&
+        selectedWorkLogItem.id === lastWorkLog?.id) ||
+      workLogSelectionsEqual(
+        selectedWorkLogItem,
+        workLogSelectionForDate(workLog.createdAtMs),
+      );
     workLogs = [...workLogs, workLog].sort(compareWorkLogs);
 
     if (shouldSelectCreatedWorkLog) {
-      selectedWorkLogId = workLog.id;
+      selectedWorkLogItem = { kind: "log", id: workLog.id };
     } else {
-      ensureSelectedWorkLog();
+      ensureSelectedWorkLogItem();
     }
 
     relativeTimeNowMs = Date.now();
@@ -207,24 +234,42 @@
         existingWorkLog.id === workLog.id ? workLog : existingWorkLog,
       )
       .sort(compareWorkLogs);
-    ensureSelectedWorkLog();
+    ensureSelectedWorkLogItem();
     relativeTimeNowMs = Date.now();
   }
 
   function selectWorkLog(id: number) {
     onActivate();
-    selectedWorkLogId = id;
+    keepSelectedDateHeaderVisible = false;
+    selectedWorkLogItem = { kind: "log", id };
+  }
+
+  function selectEmptyDay(dateKey: string) {
+    onActivate();
+    keepSelectedDateHeaderVisible = false;
+    selectedWorkLogItem = { kind: "emptyDay", dateKey };
   }
 
   function moveSelection(direction: 1 | -1) {
-    selectedWorkLogId = moveWorkLogSelection(
-      workLogs,
-      selectedWorkLogId,
+    keepSelectedDateHeaderVisible = direction === -1;
+    selectedWorkLogItem = moveWorkLogSelection(
+      visibleWorkLogItems,
+      selectedWorkLogItem,
       direction,
     );
   }
 
+  function moveSelectionToBoundary(boundary: "first" | "last") {
+    keepSelectedDateHeaderVisible = boundary === "first";
+    selectedWorkLogItem = selectWorkLogBoundary(visibleWorkLogItems, boundary);
+  }
+
   function editSelectedWorkLog() {
+    if (!selectedWorkLogItem || selectedWorkLogItem.kind !== "log") {
+      return;
+    }
+
+    const selectedWorkLogId = selectedWorkLogItem.id;
     const selectedWorkLog = workLogs.find(
       (workLog) => workLog.id === selectedWorkLogId,
     );
@@ -237,14 +282,18 @@
     onEditWorkLog(selectedWorkLog);
   }
 
-  function ensureSelectedWorkLog() {
-    if (workLogs.length === 0) {
-      selectedWorkLogId = null;
+  function ensureSelectedWorkLogItem() {
+    if (visibleWorkLogItems.length === 0) {
+      selectedWorkLogItem = null;
       return;
     }
 
-    if (!workLogs.some((workLog) => workLog.id === selectedWorkLogId)) {
-      selectedWorkLogId = workLogs[0]?.id ?? null;
+    if (
+      !visibleWorkLogItems.some((item) =>
+        workLogSelectionsEqual(item, selectedWorkLogItem),
+      )
+    ) {
+      selectedWorkLogItem = visibleWorkLogItems[0] ?? null;
     }
   }
 
@@ -253,13 +302,48 @@
 
     const selectedWorkLogElement =
       workLogListElement?.querySelector<HTMLElement>(
-        `[data-work-log-id="${selectedWorkLogId}"]`,
+        `[data-work-log-selection="${selectedWorkLogKey}"]`,
+      );
+    const selectedDateGroupElement =
+      selectedWorkLogElement?.closest<HTMLElement>(
+        "[data-work-log-date-group]",
+      );
+    const firstGroupSelectionElement =
+      selectedDateGroupElement?.querySelector<HTMLElement>(
+        "[data-work-log-selection]",
       );
+    const scrollTarget =
+      keepSelectedDateHeaderVisible &&
+      selectedWorkLogElement === firstGroupSelectionElement
+        ? selectedDateGroupElement
+        : selectedWorkLogElement;
 
-    selectedWorkLogElement?.scrollIntoView({
+    scrollTarget?.scrollIntoView({
       block: "nearest",
       inline: "nearest",
     });
+    scrollLogListToBoundary();
+    keepSelectedDateHeaderVisible = false;
+  }
+
+  function scrollLogListToBoundary() {
+    if (!workLogListElement || !selectedWorkLogItem) {
+      return;
+    }
+
+    if (workLogSelectionsEqual(selectedWorkLogItem, visibleWorkLogItems[0])) {
+      workLogListElement.scrollTop = 0;
+      return;
+    }
+
+    if (
+      workLogSelectionsEqual(
+        selectedWorkLogItem,
+        visibleWorkLogItems.at(-1) ?? null,
+      )
+    ) {
+      workLogListElement.scrollTop = workLogListElement.scrollHeight;
+    }
   }
 
   function oldestVisibleDayStartMs() {
@@ -342,6 +426,21 @@
   function isTauriRuntime() {
     return "__TAURI_INTERNALS__" in window;
   }
+
+  function emptyDaySelectionKey(dateKey: string) {
+    return workLogSelectionKey({ kind: "emptyDay", dateKey });
+  }
+
+  function isEmptyDaySelected(dateKey: string) {
+    return (
+      selectedWorkLogItem?.kind === "emptyDay" &&
+      selectedWorkLogItem.dateKey === dateKey
+    );
+  }
+
+  function isWorkLogSelected(id: number) {
+    return selectedWorkLogItem?.kind === "log" && selectedWorkLogItem.id === id;
+  }
 </script>
 
 <section
@@ -379,17 +478,32 @@
         <li class="log-empty">Loading logs...</li>
       {:else}
         {#each visibleWorkLogGroups as group (group.dateKey)}
-          <li class="log-date-group">
+          <li class="log-date-group" data-work-log-date-group={group.dateKey}>
             <h3>{group.label}</h3>
             {#if group.logs.length === 0}
-              <p class="log-empty-day">No log</p>
+              <p
+                data-work-log-selection={emptyDaySelectionKey(group.dateKey)}
+                class="log-empty-day"
+                class:log-selected={active && isEmptyDaySelected(group.dateKey)}
+              >
+                <button
+                  class="log-row-button"
+                  type="button"
+                  aria-label={`Select empty log day for ${group.label}`}
+                  onclick={() => selectEmptyDay(group.dateKey)}
+                ></button>
+                <span>No log</span>
+              </p>
             {:else}
               <ol class="log-day-list" aria-label={`${group.label} logs`}>
                 {#each group.logs as log (log.id)}
                   <li
-                    data-work-log-id={log.id}
+                    data-work-log-selection={workLogSelectionKey({
+                      kind: "log",
+                      id: log.id,
+                    })}
                     class="log-item"
-                    class:log-selected={active && selectedWorkLogId === log.id}
+                    class:log-selected={active && isWorkLogSelected(log.id)}
                   >
                     <button
                       class="log-row-button"
@@ -680,11 +794,20 @@
   }
 
   .log-empty-day {
+    isolation: isolate;
+    position: relative;
     margin: 0;
+    border-radius: 6px;
     color: #6f7784;
     font-size: 0.86rem;
   }
 
+  .log-empty-day span {
+    position: relative;
+    z-index: 2;
+    pointer-events: none;
+  }
+
   .log-item time {
     color: #a8b0be;
     font-variant-numeric: tabular-nums;
diff --git a/src/lib/keyboard.test.ts b/src/lib/keyboard.test.ts
index 87fa1bd..1fc7112 100644
--- a/src/lib/keyboard.test.ts
+++ b/src/lib/keyboard.test.ts
@@ -9,6 +9,7 @@ import {
   todoCommandFromKeydown,
   updateShortcutRequested,
   workLogCommandFromKeydown,
+  workLogKeydownAction,
   type KeyboardShortcutEvent,
 } from "$lib/keyboard";
 
@@ -224,6 +225,7 @@ describe("workLogCommandFromKeydown", () => {
     [key({ key: "ArrowDown" }), "moveDown"],
     [key({ key: "k" }), "moveUp"],
     [key({ key: "ArrowUp" }), "moveUp"],
+    [key({ key: "G", shiftKey: true }), "moveLast"],
     [key({ key: "e" }), "editSelected"],
   ] as const)("maps work log keys to commands", (event, command) => {
     expect(workLogCommandFromKeydown(event)).toBe(command);
@@ -237,4 +239,25 @@ describe("workLogCommandFromKeydown", () => {
       null,
     );
   });
+
+  it("maps gg as a key sequence for moving to the first log", () => {
+    expect(workLogKeydownAction(key({ key: "g" }), null)).toEqual({
+      command: null,
+      handled: true,
+      nextSequence: "goToFirst",
+    });
+    expect(workLogKeydownAction(key({ key: "g" }), "goToFirst")).toEqual({
+      command: "moveFirst",
+      handled: true,
+      nextSequence: null,
+    });
+  });
+
+  it("resets the gg sequence when another key is pressed", () => {
+    expect(workLogKeydownAction(key({ key: "x" }), "goToFirst")).toEqual({
+      command: null,
+      handled: false,
+      nextSequence: null,
+    });
+  });
 });
diff --git a/src/lib/keyboard.ts b/src/lib/keyboard.ts
index 378e162..20efbe3 100644
--- a/src/lib/keyboard.ts
+++ b/src/lib/keyboard.ts
@@ -19,7 +19,16 @@ export type WorkLogCommand =
   | "focusPreferred"
   | "moveDown"
   | "moveUp"
+  | "moveFirst"
+  | "moveLast"
   | "editSelected";
+export type WorkLogKeySequence = "goToFirst";
+
+export type WorkLogKeydownAction = {
+  command: WorkLogCommand | null;
+  handled: boolean;
+  nextSequence: WorkLogKeySequence | null;
+};
 
 export type KeyboardShortcutEvent = {
   key: string;
@@ -124,6 +133,8 @@ export function workLogCommandFromKeydown(
   event: KeyboardShortcutEvent,
 ): WorkLogCommand | null {
   switch (event.key) {
+    case "G":
+      return isShiftOnlyKey(event) ? "moveLast" : null;
     case "j":
     case "ArrowDown":
       return "moveDown";
@@ -137,6 +148,27 @@ export function workLogCommandFromKeydown(
   }
 }
 
+export function workLogKeydownAction(
+  event: KeyboardShortcutEvent,
+  pendingSequence: WorkLogKeySequence | null,
+): WorkLogKeydownAction {
+  if (event.key === "g" && isPlainKey(event)) {
+    return {
+      command: pendingSequence === "goToFirst" ? "moveFirst" : null,
+      handled: true,
+      nextSequence: pendingSequence === "goToFirst" ? null : "goToFirst",
+    };
+  }
+
+  const command = workLogCommandFromKeydown(event);
+
+  return {
+    command,
+    handled: command !== null,
+    nextSequence: null,
+  };
+}
+
 export function todoCommandFromKeydown(
   event: KeyboardShortcutEvent,
 ): TodoCommand | null {
@@ -173,3 +205,7 @@ export function todoCommandFromKeydown(
 function isPlainKey(event: KeyboardShortcutEvent) {
   return !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey;
 }
+
+function isShiftOnlyKey(event: KeyboardShortcutEvent) {
+  return !event.metaKey && !event.ctrlKey && !event.altKey && event.shiftKey;
+}
diff --git a/src/lib/work-log/ui.test.ts b/src/lib/work-log/ui.test.ts
index cab3348..99da593 100644
--- a/src/lib/work-log/ui.test.ts
+++ b/src/lib/work-log/ui.test.ts
@@ -2,7 +2,10 @@ import { describe, expect, it } from "vitest";
 import type { WorkLog } from "$lib/api/workLogs";
 import {
   buildRecentWorkLogGroups,
+  buildWorkLogSelectableItems,
   moveWorkLogSelection,
+  selectWorkLogBoundary,
+  workLogSelectionForDate,
 } from "$lib/work-log/ui";
 
 function workLog(overrides: Partial<WorkLog> & Pick<WorkLog, "id">): WorkLog {
@@ -72,21 +75,71 @@ describe("buildRecentWorkLogGroups", () => {
   });
 });
 
+describe("buildWorkLogSelectableItems", () => {
+  it("includes both log rows and empty-day rows in display order", () => {
+    const groups = [
+      { dateKey: "2026-05-22", label: "Today", logs: [workLog({ id: 1 })] },
+      { dateKey: "2026-05-21", label: "Yesterday", logs: [] },
+      { dateKey: "2026-05-20", label: "May 20", logs: [workLog({ id: 2 })] },
+    ];
+
+    expect(buildWorkLogSelectableItems(groups)).toEqual([
+      { kind: "log", id: 1 },
+      { kind: "emptyDay", dateKey: "2026-05-21" },
+      { kind: "log", id: 2 },
+    ]);
+  });
+});
+
 describe("moveWorkLogSelection", () => {
-  const logs = [workLog({ id: 1 }), workLog({ id: 2 }), workLog({ id: 3 })];
+  const items = [
+    { kind: "log", id: 1 },
+    { kind: "emptyDay", dateKey: "2026-05-21" },
+    { kind: "log", id: 2 },
+  ] as const;
+
+  it("selects the first or last item when nothing is selected", () => {
+    expect(moveWorkLogSelection([...items], null, 1)).toEqual(items[0]);
+    expect(moveWorkLogSelection([...items], null, -1)).toEqual(items[2]);
+  });
 
-  it("selects the first or last log when nothing is selected", () => {
-    expect(moveWorkLogSelection(logs, null, 1)).toBe(1);
-    expect(moveWorkLogSelection(logs, null, -1)).toBe(3);
+  it("moves through log and empty-day items within bounds", () => {
+    expect(moveWorkLogSelection([...items], items[0], 1)).toEqual(items[1]);
+    expect(moveWorkLogSelection([...items], items[1], 1)).toEqual(items[2]);
+    expect(moveWorkLogSelection([...items], items[2], 1)).toEqual(items[2]);
+    expect(moveWorkLogSelection([...items], items[0], -1)).toEqual(items[0]);
   });
 
-  it("moves within bounds", () => {
-    expect(moveWorkLogSelection(logs, 1, 1)).toBe(2);
-    expect(moveWorkLogSelection(logs, 3, 1)).toBe(3);
-    expect(moveWorkLogSelection(logs, 1, -1)).toBe(1);
+  it("clears selection for an empty list", () => {
+    expect(moveWorkLogSelection([], items[0], 1)).toBeNull();
+  });
+});
+
+describe("selectWorkLogBoundary", () => {
+  const items = [
+    { kind: "log", id: 1 },
+    { kind: "emptyDay", dateKey: "2026-05-21" },
+    { kind: "log", id: 2 },
+  ] as const;
+
+  it("selects the first or last item", () => {
+    expect(selectWorkLogBoundary([...items], "first")).toEqual(items[0]);
+    expect(selectWorkLogBoundary([...items], "last")).toEqual(items[2]);
   });
 
   it("clears selection for an empty list", () => {
-    expect(moveWorkLogSelection([], 1, 1)).toBeNull();
+    expect(selectWorkLogBoundary([], "first")).toBeNull();
+    expect(selectWorkLogBoundary([], "last")).toBeNull();
+  });
+});
+
+describe("workLogSelectionForDate", () => {
+  it("builds an empty-day selection key from a local timestamp", () => {
+    expect(workLogSelectionForDate(new Date(2026, 4, 22, 9).getTime())).toEqual(
+      {
+        kind: "emptyDay",
+        dateKey: "2026-05-22",
+      },
+    );
   });
 });
diff --git a/src/lib/work-log/ui.ts b/src/lib/work-log/ui.ts
index a42d243..5a5f44a 100644
--- a/src/lib/work-log/ui.ts
+++ b/src/lib/work-log/ui.ts
@@ -11,6 +11,10 @@ export type WorkLogGroup = {
   logs: WorkLog[];
 };
 
+export type WorkLogSelection =
+  | { kind: "log"; id: number }
+  | { kind: "emptyDay"; dateKey: string };
+
 export function buildRecentWorkLogGroups(
   logs: WorkLog[],
   todayTimestampMs: number,
@@ -40,24 +44,81 @@ export function buildRecentWorkLogGroups(
   return groups;
 }
 
+export function buildWorkLogSelectableItems(
+  groups: WorkLogGroup[],
+): WorkLogSelection[] {
+  return groups.flatMap((group): WorkLogSelection[] => {
+    if (group.logs.length === 0) {
+      return [{ kind: "emptyDay", dateKey: group.dateKey }];
+    }
+
+    return group.logs.map((log) => ({ kind: "log", id: log.id }));
+  });
+}
+
 export function moveWorkLogSelection(
-  logs: WorkLog[],
-  selectedWorkLogId: number | null,
+  items: WorkLogSelection[],
+  selectedItem: WorkLogSelection | null,
   direction: 1 | -1,
-) {
-  if (logs.length === 0) {
+): WorkLogSelection | null {
+  if (items.length === 0) {
     return null;
   }
 
-  const currentIndex = logs.findIndex((log) => log.id === selectedWorkLogId);
+  const currentIndex = items.findIndex((item) =>
+    workLogSelectionsEqual(item, selectedItem),
+  );
   const nextIndex =
     currentIndex === -1
       ? direction === 1
         ? 0
-        : logs.length - 1
-      : Math.min(Math.max(currentIndex + direction, 0), logs.length - 1);
+        : items.length - 1
+      : Math.min(Math.max(currentIndex + direction, 0), items.length - 1);
+
+  return items[nextIndex] ?? null;
+}
+
+export function selectWorkLogBoundary(
+  items: WorkLogSelection[],
+  boundary: "first" | "last",
+): WorkLogSelection | null {
+  if (items.length === 0) {
+    return null;
+  }
+
+  return boundary === "first" ? (items[0] ?? null) : (items.at(-1) ?? null);
+}
+
+export function workLogSelectionsEqual(
+  a: WorkLogSelection | null,
+  b: WorkLogSelection | null,
+) {
+  if (!a || !b || a.kind !== b.kind) {
+    return false;
+  }
+
+  if (a.kind === "log" && b.kind === "log") {
+    return a.id === b.id;
+  }
+
+  if (a.kind === "emptyDay" && b.kind === "emptyDay") {
+    return a.dateKey === b.dateKey;
+  }
+
+  return false;
+}
+
+export function workLogSelectionKey(selection: WorkLogSelection) {
+  return selection.kind === "log"
+    ? `log:${selection.id}`
+    : `empty-day:${selection.dateKey}`;
+}
 
-  return logs[nextIndex]?.id ?? null;
+export function workLogSelectionForDate(timestampMs: number): WorkLogSelection {
+  return {
+    kind: "emptyDay",
+    dateKey: localDateKey(new Date(timestampMs)),
+  };
 }
 
 function localDateKey(date: Date) {
diff --git a/src/routes/+page.svelte b/src/routes/+page.svelte
index 877cb92..4761126 100644
--- a/src/routes/+page.svelte
+++ b/src/routes/+page.svelte
@@ -36,11 +36,12 @@
     settingsShortcutRequested,
     todoCommandFromKeydown,
     updateShortcutRequested,
-    workLogCommandFromKeydown,
+    workLogKeydownAction,
     type PomodoroCommand,
     type SectionId,
     type TodoCommand,
     type WorkLogCommand,
+    type WorkLogKeySequence,
   } from "$lib/keyboard";
   import {
     isCurrentNotificationPermissionGranted,
@@ -66,6 +67,7 @@
     { id: "log", title: "Log", shortcut: "⌘3" },
   ];
   const UPDATE_CHECK_COOLDOWN_MS = 24 * 60 * 60 * 1000;
+  const WORK_LOG_KEY_SEQUENCE_TIMEOUT_MS = 700;
   let activeSection = $state<SectionId>("log");
   let pomodoroCommandRequest = $state<{
     id: number;
@@ -94,6 +96,8 @@
   let lastUpdateCheckAttemptAt = 0;
   let settingsDialogOpen = $state(false);
   let keyboardShortcutsDialogOpen = $state(false);
+  let workLogKeySequence = $state<WorkLogKeySequence | null>(null);
+  let workLogKeySequenceTimeout: number | null = null;
   let quickEntryGlobalShortcut = $state(DEFAULT_QUICK_ENTRY_GLOBAL_SHORTCUT);
   let pomodoroFocusDurationMinutes = $state(
     DEFAULT_POMODORO_FOCUS_DURATION_MINUTES,
@@ -153,6 +157,7 @@
       disposed = true;
       window.clearInterval(dateInterval);
       window.clearInterval(updateInterval);
+      clearWorkLogKeySequenceTimeout();
       unlistenFocusChange?.();
     };
   });
@@ -240,11 +245,16 @@
   }
 
   function handleWorkLogSectionKeydown(event: KeyboardEvent) {
-    const command = workLogCommandFromKeydown(event);
+    const action = workLogKeydownAction(event, workLogKeySequence);
 
-    if (command) {
+    setWorkLogKeySequence(action.nextSequence);
+
+    if (action.handled) {
       event.preventDefault();
-      requestWorkLogCommand(command);
+    }
+
+    if (action.command) {
+      requestWorkLogCommand(action.command);
     }
   }
 
@@ -324,6 +334,27 @@
     };
   }
 
+  function setWorkLogKeySequence(sequence: WorkLogKeySequence | null) {
+    workLogKeySequence = sequence;
+    clearWorkLogKeySequenceTimeout();
+
+    if (sequence) {
+      workLogKeySequenceTimeout = window.setTimeout(() => {
+        workLogKeySequence = null;
+        workLogKeySequenceTimeout = null;
+      }, WORK_LOG_KEY_SEQUENCE_TIMEOUT_MS);
+    }
+  }
+
+  function clearWorkLogKeySequenceTimeout() {
+    if (workLogKeySequenceTimeout === null) {
+      return;
+    }
+
+    window.clearTimeout(workLogKeySequenceTimeout);
+    workLogKeySequenceTimeout = null;
+  }
+
   function requestWorkLogEdit(workLog: WorkLog) {
     workLogEditRequest = {
       id: ++workLogEditRequestId,