diff --git a/.githooks/post-commit b/.githooks/post-commit
new file mode 100755
index 0000000..0ba11e8
--- /dev/null
+++ b/.githooks/post-commit
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+#
+# After a commit that bumps the crate version, create the matching
+# vX.Y.Z tag if it does not exist yet. Pushing that tag is what
+# triggers the GitHub Release pipeline (.github/workflows/release.yml).
+#
+# Enable the repo hooks once per clone:
+#   git config core.hooksPath .githooks   (or ./scripts/install-hooks.sh)
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+# Only act on commits that changed the `version` line of Cargo.toml.
+if ! git diff -U0 HEAD~1 HEAD -- Cargo.toml 2>/dev/null | grep -qE '^\+version = "[0-9]+\.[0-9]+\.[0-9]+"'; then
+  exit 0
+fi
+
+VERSION="$(grep -m1 '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')"
+TAG="v$VERSION"
+
+# Nothing to do if the tag already exists (e.g. created manually).
+[ -z "$(git tag -l "$TAG")" ] || exit 0
+
+git tag "$TAG"
+echo "post-commit: created tag $TAG"
+echo "publish the release with: git push origin master --tags"
diff --git a/.githooks/pre-commit b/.githooks/pre-commit
new file mode 100755
index 0000000..acc9300
--- /dev/null
+++ b/.githooks/pre-commit
@@ -0,0 +1,51 @@
+#!/usr/bin/env bash
+#
+# Require every code change to bump the crate version in the SAME commit.
+# "Code" means anything that ships in the release binary: src/, tests/,
+# Cargo.toml and Cargo.lock. Docs, scripts and CI changes are exempt.
+#
+# Rationale: releases are tag-driven and the version lives in Cargo.toml,
+# so a code commit without a version bump can never become a release.
+#
+# Enable the repo hooks once per clone:
+#   git config core.hooksPath .githooks   (or ./scripts/install-hooks.sh)
+set -euo pipefail
+
+cd "$(git rev-parse --show-toplevel)"
+
+CODE_RE='^(src/|tests/|Cargo\.toml$|Cargo\.lock$)'
+
+# No code changes in this commit: nothing to check.
+git diff --cached --name-only | grep -qE "$CODE_RE" || exit 0
+
+# The commit must change the `version` line of Cargo.toml (staged).
+if ! git diff --cached -U0 -- Cargo.toml | grep -qE '^\+version = "[0-9]+\.[0-9]+\.[0-9]+"'; then
+  cat >&2 <<'EOF'
+error: this commit changes code but does not bump the version.
+
+Every code change must ship as a new release: bump the version and
+stage it together with your changes, e.g.:
+
+  ./scripts/bump-version.sh patch   # or: minor / major
+  git add Cargo.toml Cargo.lock
+
+(bypass with: git commit --no-verify)
+EOF
+  exit 1
+fi
+
+NEW_VER="$(git show :Cargo.toml | grep -m1 '^version = ' | sed 's/version = "\(.*\)"/\1/')"
+
+# The tag must be fresh — reusing a released version would clash.
+if [ -n "$(git tag -l "v$NEW_VER")" ]; then
+  echo "error: tag v$NEW_VER already exists; bump to a fresh version" >&2
+  exit 1
+fi
+
+# Cargo.lock must be staged in sync with the new version.
+LOCK_VER="$(git show :Cargo.lock | awk '/^name = "basilk"$/{getline; print; exit}' | sed 's/version = "\(.*\)"/\1/')"
+if [ "$NEW_VER" != "$LOCK_VER" ]; then
+  echo "error: Cargo.toml bumps to $NEW_VER but the staged Cargo.lock still says $LOCK_VER" >&2
+  echo "run ./scripts/bump-version.sh (it updates both) and stage Cargo.lock" >&2
+  exit 1
+fi
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
new file mode 100644
index 0000000..26f0e03
--- /dev/null
+++ b/.github/workflows/ci.yml
@@ -0,0 +1,79 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+
+env:
+  CARGO_TERM_COLOR: always
+
+jobs:
+  version-bump:
+    name: Version bumped with code changes
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      # Backstop for the local pre-commit hook: any change to the code
+      # that ships in the release binary (src/, tests/, Cargo manifests)
+      # must come with a version bump in Cargo.toml, otherwise the
+      # change can never become a GitHub Release.
+      - name: Code changes must bump the version
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            BASE="${{ github.event.pull_request.base.sha }}"
+          else
+            BASE="${{ github.event.before }}"
+          fi
+          if [ -z "$BASE" ] || [ "$BASE" = "0000000000000000000000000000000000000000" ]; then
+            echo "no base revision to compare against; skipping"
+            exit 0
+          fi
+          if ! git diff --name-only "$BASE" HEAD | grep -qE '^(src/|tests/|Cargo\.toml$|Cargo\.lock$)'; then
+            echo "no code changes; nothing to check"
+            exit 0
+          fi
+          OLD="$(git show "$BASE":Cargo.toml | grep -m1 '^version = ')"
+          NEW="$(grep -m1 '^version = ' Cargo.toml)"
+          if [ "$OLD" = "$NEW" ]; then
+            echo "::error::code changed but the Cargo.toml version was not bumped (still ${NEW#version = })"
+            echo "::error::bump it with ./scripts/bump-version.sh [patch|minor|major] and include it in the change"
+            exit 1
+          fi
+          echo "version bumped: $OLD -> $NEW"
+
+  check:
+    name: Build & Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v5
+
+      - name: Install Rust toolchain
+        uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt, clippy
+
+      - name: Cache cargo registry
+        uses: actions/cache@v5
+        with:
+          path: |
+            ~/.cargo/registry
+            ~/.cargo/git
+            target
+          key: cargo-${{ runner.os }}-${{ hashFiles('**/Cargo.lock') }}
+          restore-keys: cargo-${{ runner.os }}-
+
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+
+      - name: Clippy
+        run: cargo clippy --all-targets --all-features -- -D warnings
+
+      - name: Build
+        run: cargo build --verbose
+
+      - name: Test
+        run: cargo test --verbose
diff --git a/.github/workflows/lint_rust.yaml b/.github/workflows/lint_rust.yaml
index a8e3e16..068846a 100644
--- a/.github/workflows/lint_rust.yaml
+++ b/.github/workflows/lint_rust.yaml
@@ -9,10 +9,21 @@ jobs:
   lint_rust:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v5
       - uses: hecrj/setup-rust-action@v2
         with:
           rust-version: "stable"
       - name: "Lint Rust"
         run: "cargo fmt --all -- --check"
-...
+      - name: "Install cargo-llvm-cov"
+        uses: taiki-e/install-action@cargo-llvm-cov
+      - name: "Add llvm-tools-preview"
+        run: "rustup component add llvm-tools-preview"
+      # The whole test suite runs under coverage instrumentation. Local runs
+      # measure ~99.5% line coverage; the only uncovered lines are the
+      # real-terminal glue in main.rs (main/init_terminal/restore_terminal
+      # and CrosstermSource::next_key) which cannot run inside a unit test.
+      # The 95% gate catches regressions without being flaky across
+      # platforms. Measure locally with: cargo llvm-cov --workspace
+      - name: "Test with coverage"
+        run: "cargo llvm-cov --workspace --fail-under-lines 95"
diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml
new file mode 100644
index 0000000..e8935f8
--- /dev/null
+++ b/.github/workflows/release.yml
@@ -0,0 +1,126 @@
+---
+name: Release
+
+# Tag-driven release pipeline:
+# - Pushing a `vX.Y.Z` tag builds release binaries for Linux, macOS
+#   (Intel + Apple Silicon) and Windows and publishes them to a GitHub
+#   Release with auto-generated notes.
+# - The version number is bumped manually with each code change
+#   (./scripts/bump-version.sh or by editing Cargo.toml) and committed
+#   alongside the code; the post-commit hook creates the vX.Y.Z tag.
+#   The workflow never bumps versions or commits on its own.
+# - The tag must match the version declared in Cargo.toml.
+# - workflow_dispatch: re-publish an existing tag (e.g. after a build fix).
+on:
+  push:
+    tags: ['v*']
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: 'Existing tag to build & publish, e.g. v0.2.6 (must match Cargo.toml)'
+        required: true
+
+permissions:
+  contents: write
+
+# One release at a time; concurrent runs queue up instead of racing.
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  release:
+    name: Resolve & verify version
+    runs-on: ubuntu-latest
+    outputs:
+      version: ${{ steps.meta.outputs.version }}
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          fetch-depth: 0
+
+      - name: Resolve version from tag
+        id: meta
+        run: |
+          if [ "$GITHUB_EVENT_NAME" = "workflow_dispatch" ]; then
+            TAG="${{ github.event.inputs.tag }}"
+          else
+            TAG="${GITHUB_REF_NAME}"
+          fi
+          echo "version=${TAG#v}" >> "$GITHUB_OUTPUT"
+
+      # Build from the exact release commit, not the latest master
+      - uses: actions/checkout@v5
+        with:
+          ref: v${{ steps.meta.outputs.version }}
+
+      - name: Verify tag matches Cargo.toml
+        run: |
+          CARGO_VERSION="$(grep -m1 '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')"
+          if [ "$CARGO_VERSION" != "${{ steps.meta.outputs.version }}" ]; then
+            echo "::error::tag v${{ steps.meta.outputs.version }} but Cargo.toml declares $CARGO_VERSION"
+            exit 1
+          fi
+
+  build:
+    name: Build ${{ matrix.target }}
+    needs: release
+    runs-on: ${{ matrix.os }}
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: ubuntu-latest
+            target: x86_64-unknown-linux-gnu
+            bin: basilk
+            asset: basilk-x86_64-unknown-linux-gnu
+          - os: macos-14
+            target: aarch64-apple-darwin
+            bin: basilk
+            asset: basilk-aarch64-apple-darwin
+          # Cross-compiled from the ARM runner; the project has no C deps
+          - os: macos-14
+            target: x86_64-apple-darwin
+            bin: basilk
+            asset: basilk-x86_64-apple-darwin
+          - os: windows-latest
+            target: x86_64-pc-windows-msvc
+            bin: basilk.exe
+            asset: basilk-x86_64-pc-windows-msvc.exe
+    steps:
+      - uses: actions/checkout@v5
+        with:
+          ref: v${{ needs.release.outputs.version }}
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - name: Build release binary
+        run: cargo build --release --target ${{ matrix.target }}
+      - name: Stage binary with platform name
+        run: cp target/${{ matrix.target }}/release/${{ matrix.bin }} ${{ matrix.asset }}
+        shell: bash
+      - name: Upload artifact
+        uses: actions/upload-artifact@v7
+        with:
+          name: ${{ matrix.asset }}
+          path: ${{ matrix.asset }}
+          if-no-files-found: error
+
+  publish:
+    name: Publish GitHub Release
+    needs: [release, build]
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/download-artifact@v8
+        with:
+          path: artifacts
+          merge-multiple: true
+      - name: List artifacts
+        run: ls -lh artifacts
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v3
+        with:
+          tag_name: v${{ needs.release.outputs.version }}
+          name: v${{ needs.release.outputs.version }}
+          files: artifacts/*
+          generate_release_notes: true
diff --git a/AGENTS.md b/AGENTS.md
new file mode 100644
index 0000000..906cfbf
--- /dev/null
+++ b/AGENTS.md
@@ -0,0 +1,78 @@
+# Basilk Agent Guide
+
+Basilk is a TUI-based kanban task manager written in Rust using `ratatui`.
+
+## Essential Commands
+
+- **Build**: `cargo build`
+- **Run**: `cargo run`
+- **Test**: `cargo test` (unit tests live in per-module `#[cfg(test)]` blocks; `src/property_tests.rs` holds proptest-based fuzz/property tests)
+- **Coverage**: `cargo llvm-cov --workspace` (install with `cargo install cargo-llvm-cov`; CI runs it via `taiki-e/install-action` with `--fail-under-lines 95`). Local runs measure ~99.5% line coverage. The only uncovered lines are the real-terminal glue in `main.rs` (`main`, `init_terminal`, `restore_terminal`, `CrosstermSource::next_key`), which cannot run inside a unit test; everything else — including the full event loop and every view/modal render — is covered by in-process tests.
+- **Releases**: Tag-driven. **Every code change must bump the version in the same commit** — a code commit without a version bump can never become a release, so this is enforced twice: locally by `.githooks/pre-commit` (blocks the commit; enable once per clone with `./scripts/install-hooks.sh`) and on GitHub by the `version-bump` job in `.github/workflows/ci.yml`. "Code" means `src/`, `tests/`, `Cargo.toml`, `Cargo.lock`; docs/scripts/CI changes are exempt. `./scripts/bump-version.sh [patch|minor|major]` updates `Cargo.toml` + `Cargo.lock` in the working tree only (no commit, no tag); the `.githooks/post-commit` hook then creates the `vX.Y.Z` tag automatically after a version-bump commit. Pushing that tag triggers `.github/workflows/release.yml`, which verifies the tag matches `Cargo.toml`, builds binaries for Linux / macOS (Intel + ARM) / Windows and publishes a GitHub Release. The workflow never bumps versions or commits on its own; `workflow_dispatch` re-publishes an existing tag (takes the tag name as input). A `concurrency: group: release` queue prevents racing builds.
+- **Benchmarks**: `./scripts/bench.sh` (or `cargo test --release --bin basilk perf_tests -- --ignored --nocapture`) runs the opt-in `perf_tests` module — scaling of `load_items`, full-frame render at 2k tasks, Markdown rendering, JSON persistence. Typical release-build numbers: ~0.3 ms/frame at 2k tasks (250 ms budget), ~2 ms for 10k-task `load_items`, idle CPU 0%.
+- **Lint**: `cargo fmt --all -- --check` and `cargo clippy --all-targets --all-features -- -D warnings` (both used in CI)
+- **Format**: `cargo fmt`
+
+## Project Structure
+
+- `src/main.rs`: Entry point, terminal initialization/restore (including the panic hook), CLI dispatch, and `CrosstermSource` (the real-terminal `KeySource`). Everything else lives in `app.rs`.
+- `src/app.rs`: The `App` struct, `ViewMode`, `KeyAction`, the `KeySource` trait, all `handle_*` key handlers, board logic, timer tick/settle, `App::render`, and the `run_with_source` event loop. Its tests live in `src/app/tests.rs` (handlers, board, event loop, timer behaviour, rendering) and `src/app/perf_tests.rs` (opt-in benchmarks).
+- `src/cli.rs`: Simple CLI argument handling (`--version` prints the version, `--help`/`-h` prints the `USAGE` text; both exit without starting the TUI).
+- `src/json.rs`: Data persistence layer (JSON format).
+- `src/markdown.rs`: Markdown → ratatui `Text` renderer (`pulldown-cmark` event stream + style stack) used by the note preview.
+- `src/migration.rs`: JSON data schema migrations.
+- `src/note.rs`: Global note data model and logic (project-independent Markdown memos).
+- `src/project.rs`: Project data model and logic.
+- `src/task.rs`: Task data model, status/priority constants, and logic.
+- `src/timer.rs`: Task-bound stopwatch/countdown runtime state (not persisted); on settle the elapsed seconds are accumulated into `Task.time_spent_secs`.
+- `src/ui.rs`: UI utility functions for creating modals and layouts.
+- `src/view.rs`: Higher-level UI rendering logic (rendering specific views/modals).
+- `src/util.rs`: Miscellaneous utility functions.
+- `src/property_tests.rs`: `#[cfg(test)]`-only module with proptest property/fuzz tests.
+- `src/test_utils.rs`: `#[cfg(test)]`-only shared fixtures (`make_app`, `make_task`, `setup_temp_config`, `ENV_LOCK`).
+
+## Code Patterns
+
+### App State Management
+The `App` struct in `src/app.rs` manages the application state, including selected indices for projects and tasks, the current `ViewMode`, and loaded data.
+
+### View Modes
+`ViewMode` enum in `src/app.rs` defines the different screens and states (e.g., `ViewProjects`, `AddTask`, `ViewTasks`).
+
+### Data Persistence
+- Data is stored in `basilk_data.json` (a versioned wrapper around the project list, plus a global `notes` list) in the user's config directory; older releases used per-version files (e.g., `911fc.json`) that are migrated on startup.
+- `Json::read()` (returns `Result`; a corrupt data file is a startup error with the file path, not a panic) and `Json::write()` handle loading and saving the entire project list; `Json::read_notes()` / `Json::write_notes()` do the same for notes. Both write paths read the counterpart back from disk first with a strict parse, so writing projects never drops notes and vice versa — and a write fails without touching the file when the on-disk data cannot be parsed, instead of overwriting the corrupt file with an empty counterpart. Writes are atomic: the payload goes to a sibling `basilk_data.json.tmp` file which is then renamed over the target, so an interrupted write cannot leave a truncated data file.
+- Set the `BASILK_CONFIG_DIR` env var to redirect storage (used by tests with a temp dir).
+- Migrations are handled in `migration.rs` by mapping version hashes to transformation functions. A legacy migration deletes the old versioned file only after the rewritten `basilk_data.json` verifies (a recursive `Json::check()`), and the deletion is best-effort.
+
+### TUI Logic
+- Uses `ratatui` with `crossterm` backend.
+- `App::render` in `src/app.rs` delegates rendering to `View` methods in `view.rs`.
+- Modals are created using `Ui` helper methods in `ui.rs`.
+
+## Conventions
+
+- **Naming**: Standard Rust naming conventions (CamelCase for types, snake_case for functions/variables).
+- **Static Constants**: Used for task statuses (`TASK_STATUS_DONE`, etc.) and priorities.
+- **Error Handling**: Uses `Box<dyn Error>` in `main` and `Result` elsewhere. `unwrap()` is frequently used in data operations.
+
+## Gotchas
+
+- **Input Handling**: `tui-input` is used for text fields. Note that the event loop (`App::run_with_source` in `src/app.rs`) filters for `KeyEventKind::Press` to avoid double-processing on Windows.
+- **Panic Safety**: `init_terminal` installs a panic hook that calls `restore_terminal()` before delegating to the default hook, so a panic never strands the terminal in raw mode / alternate screen. Keep this hook in place when touching terminal setup.
+- **Event Loop**: `CrosstermSource` in `src/main.rs` uses `event::poll(250ms)` instead of a blocking read so the task timer (`App.timer`) can tick and redraw every second; `App::tick_timer` runs after each iteration of `App::run_with_source` in `src/app.rs`.
+- **Timers**: `s` in the task view starts a stopwatch bound to the selected task; `c` in either view starts a global pomodoro countdown (`src/timer.rs`, binding is `Option<TimerTaskBinding>`). A stopwatch persists its seconds on settle (`App::settle_timer` → `Task::add_time_spent` into `time_spent_secs`): on stop or on quit; a pomodoro never persists — at zero it rings the terminal bell once and stays visible in a finished state (modal shows big block digits and "time's up!") until the user dismisses it with any key. Timers keep running across view switches; deleting the bound task drops the timer, deleting a project drops or re-indexes it. Timer modals return to the view they were opened from via `previous_view_mode`.
+- **Time Estimate**: Each task has an `estimated_hours` field (0 = no estimate, editable with `g` in the task details view); the details view and timer modal show the percentage of the estimate already spent (both computed via `Task::estimate_progress`, so the two cannot drift), and the task list renders a `[x%]` suffix. Progress math lives in `Task::estimate_progress` (saturating arithmetic — arbitrary JSON values must not overflow). Timers are bound to a task by `(project_index, task_title)`; renaming a bound task updates the timer, deleting it drops the timer. Task titles are unique within a project (the title is the task's stable identity): `Task::create` and `Task::rename` reject duplicates and return `false`, and the add/rename handlers keep the input view open on a rejection so nothing is silently dropped.
+- **Data Loading**: `Project::reload` and `Task::reload` read the entire JSON file from disk. Changes are written back to disk immediately after most operations (create, rename, delete, change status/priority).
+- **Sorting**: Tasks are sorted during `Task::load_items`. `sort_by_key` is stable and the priority sort runs last, so the final order is **priority-major** with status as the tie-breaker; done tasks (priority reset to NONE) end up last. Unknown statuses/priorities (hand-edited JSON) map past the end of the known sort keys, so they sort last instead of first. `load_items` also normalizes `status == Done ⇒ priority = NONE` on every load, restoring the invariant that hand-edited JSON can break (in-app transitions enforce it in `Task::change_status`).
+- **Board View**: `b` in the task view toggles a kanban board (three lanes: Up Next / On Going / Done) rendered by `View::show_board` in `view.rs`. It is a display mode of `ViewMode::ViewTasks`, not a separate `ViewMode`, so all task keybindings work unchanged. State lives in `App.board_view`, `App.board_lane`, and `App.board_lane_states` (per-lane `ListState`); `selected_task_index` (full sorted-list index) remains the selection source of truth — lane navigation just translates (lane, row) into it via `Task::lane_indices`, and `App::board_sync` (called at the end of `Task::load_items` when the board is active, plus explicitly after `DeleteTask`'s `select_previous` via `App::delete_current_task`) re-derives the lane/row after any mutation so the focus follows a task that changed status. While the board is active, `Task::load_items` skips the `hide_done_tasks` filter (the board always shows the Done lane) and `t` is a no-op; `←`/`→` switch lanes (`←` no longer goes back to projects), `Esc` still does. Task lines are built by the shared `Task::repr_spans` helper so the list and board renderings cannot drift.
+- **Notes**: `m` in the project view opens the global notes list (`ViewMode::ViewNotes`); notes live in `App.notes` (model in `src/note.rs`) and are stored in the same `basilk_data.json` wrapper (`#[serde(default)]`, so pre-notes files load unchanged; the `e5a1c` migration only bumps the version). `Enter`/`v` opens `ViewNote`, a full-page Markdown preview (`View::show_note` → `markdown::render_markdown`) scrolled via `App.note_scroll`, which is clamped at render time against an estimated wrapped line count (`G` just sets `u16::MAX`). `e` opens `EditNote`, a full-page `tui-textarea` editor stored in `App.note_textarea` (created on entry from the body lines); every key except `Esc` is forwarded to the textarea, and `Esc` saves (`Note::update_body`) and returns to the preview. `ViewNote`/`EditNote` bypass `View::show_items` in `App::render` and take the whole main area. `Note::create` and `Note::rename` reject empty titles (silent no-op, matching the project/task style); `rename` and `update_body` both stamp `updated_at`.
+- **Testing**: Tests share fixtures from `src/test_utils.rs`. Any test touching the disk layer must hold `ENV_LOCK` and use `setup_temp_config()` (sets `BASILK_CONFIG_DIR`).
+  - **Event loop**: `App::run_with_source` drives the whole draw/dispatch/tick loop against an injected `KeySource`; tests feed it a queue of synthetic `KeyEvent`s (see `app::tests::event_loop` in `src/app/tests.rs`). `CrosstermSource` (the real terminal poll/read, in `src/main.rs`) is the one `KeySource` that tests cannot drive in-process.
+  - **Rendering**: `App::render` (and the `View::show_*` functions) are exercised with `ratatui::TestBackend` across every `ViewMode`, including the timer/help/details/delete modals and the board view; `app::tests::render` asserts on the drawn buffer content (`CompletedFrame::buffer`).
+  - **Key handlers**: every `App::handle_*` method has direct unit tests (`app::tests::handlers`). Handlers change views themselves via `self.change_view(...)`; tests must set `app.view_mode` before calling a handler that depends on `use_state()` (navigation, modal lists), because `use_state()` picks the `ListState` from the current `view_mode`.
+  - **CLI**: `Cli::parse` is pure and unit-tested; the `--version` / `--help` print/exit lives in `main` (uncovered glue) and is verified end-to-end by `tests/cli.rs`, which spawns the real binary via `CARGO_BIN_EXE_basilk`.
+- **Migrations**: If you change the data schema (e.g., in `Project` or `Task` structs), you **must** add a new migration in `migration.rs` and update `JSON_VERSIONS`.
+
+## Configuration
+There is currently no config file mechanism in the codebase (an earlier `src/config.rs` with `ui.show_help` no longer exists). All behavior is compiled in; per-task settings like `estimated_hours` live in the JSON data.
diff --git a/Cargo.lock b/Cargo.lock
index 2a1e253..3a9c776 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 3
+version = 4
 
 [[package]]
 name = "ahash"
@@ -11,7 +11,7 @@ dependencies = [
  "cfg-if",
  "once_cell",
  "version_check",
- "zerocopy",
+ "zerocopy 0.7.35",
 ]
 
 [[package]]
@@ -20,6 +20,15 @@ version = "0.2.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "5c6cb57a04249c6480766f7f7cef5467412af1490f8d1e243141daddada3264f"
 
+[[package]]
+name = "android_system_properties"
+version = "0.1.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "819e7219dbd41043ac279b19830f2efc897156490d7fd6ea916720117ee66311"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "autocfg"
 version = "1.3.0"
@@ -28,21 +37,46 @@ checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
 name = "basilk"
-version = "0.2.1"
+version = "0.2.28"
 dependencies = [
+ "chrono",
  "dirs",
+ "proptest",
+ "pulldown-cmark",
  "ratatui",
  "serde",
  "serde_json",
- "toml",
+ "tempfile",
  "tui-input",
+ "tui-textarea",
 ]
 
+[[package]]
+name = "bit-set"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08807e080ed7f9d5433fa9b275196cfc35414f66a0c79d864dc51a0d825231a3"
+dependencies = [
+ "bit-vec",
+]
+
+[[package]]
+name = "bit-vec"
+version = "0.8.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5e764a1d40d510daf35e07be9eb06e75770908c27d411ee6c92109c9840eaaf7"
+
 [[package]]
 name = "bitflags"
-version = "2.6.0"
+version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
+checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
+
+[[package]]
+name = "bumpalo"
+version = "3.19.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5dd9dc738b7a8311c7ade152424974d8115f2cdad61e8dab8dac9f2362298510"
 
 [[package]]
 name = "cassowary"
@@ -59,12 +93,35 @@ dependencies = [
  "rustversion",
 ]
 
+[[package]]
+name = "cc"
+version = "1.2.53"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "755d2fce177175ffca841e9a06afdb2c4ab0f593d53b4dee48147dfaade85932"
+dependencies = [
+ "find-msvc-tools",
+ "shlex",
+]
+
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "chrono"
+version = "0.4.43"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fac4744fb15ae8337dc853fee7fb3f4e48c0fbaa23d0afe49c447b4fab126118"
+dependencies = [
+ "iana-time-zone",
+ "js-sys",
+ "num-traits",
+ "wasm-bindgen",
+ "windows-link",
+]
+
 [[package]]
 name = "compact_str"
 version = "0.7.1"
@@ -78,6 +135,12 @@ dependencies = [
  "static_assertions",
 ]
 
+[[package]]
+name = "core-foundation-sys"
+version = "0.8.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "773648b94d0e5d620f64f280777445740e61fe701025087ec8b57f45c791888b"
+
 [[package]]
 name = "crossterm"
 version = "0.27.0"
@@ -121,7 +184,7 @@ dependencies = [
  "libc",
  "option-ext",
  "redox_users",
- "windows-sys",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]
@@ -131,10 +194,41 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "60b1af1c220855b6ceac025d3f6ecdd2b7c4894bfe9cd9bda4fbb4bc7c0d4cf0"
 
 [[package]]
-name = "equivalent"
-version = "1.0.1"
+name = "errno"
+version = "0.3.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys 0.61.2",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
+
+[[package]]
+name = "find-msvc-tools"
+version = "0.1.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8591b0bcc8a98a64310a2fae1bb3e9b8564dd10e381e6e28010fde8e8e8568db"
+
+[[package]]
+name = "fnv"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
+
+[[package]]
+name = "getopts"
+version = "0.2.24"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cfe4fbac503b8d1f88e6676011885f34b7174f46e59956bba534ba83abded4df"
+dependencies = [
+ "unicode-width 0.2.2",
+]
 
 [[package]]
 name = "getrandom"
@@ -147,6 +241,29 @@ dependencies = [
  "wasi",
 ]
 
+[[package]]
+name = "getrandom"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "899def5c37c4fd7b2664648c28120ecec138e4d395b459e5ca34f9cce2dd77fd"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 5.3.0",
+ "wasip2",
+]
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi 6.0.0",
+]
+
 [[package]]
 name = "hashbrown"
 version = "0.14.5"
@@ -164,13 +281,27 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
 [[package]]
-name = "indexmap"
-version = "2.5.0"
+name = "iana-time-zone"
+version = "0.1.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68b900aa2f7301e21c36462b170ee99994de34dff39a4a6a528e80e7376d07e5"
+checksum = "33e57f83510bb73707521ebaffa789ec8caf86f9657cad665b092b581d40e9fb"
 dependencies = [
- "equivalent",
- "hashbrown",
+ "android_system_properties",
+ "core-foundation-sys",
+ "iana-time-zone-haiku",
+ "js-sys",
+ "log",
+ "wasm-bindgen",
+ "windows-core",
+]
+
+[[package]]
+name = "iana-time-zone-haiku"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f31827a206f56af32e590ba56d5d2d085f558508192593743f16b2306495269f"
+dependencies = [
+ "cc",
 ]
 
 [[package]]
@@ -188,11 +319,21 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
+[[package]]
+name = "js-sys"
+version = "0.3.85"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c942ebf8e95485ca0d52d97da7c5a2c387d0e7f0ba4c35e93bfcaee045955b3"
+dependencies = [
+ "once_cell",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "libc"
-version = "0.2.155"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "libredox"
@@ -204,6 +345,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "lock_api"
 version = "0.4.12"
@@ -244,7 +391,16 @@ dependencies = [
  "libc",
  "log",
  "wasi",
- "windows-sys",
+ "windows-sys 0.48.0",
+]
+
+[[package]]
+name = "num-traits"
+version = "0.2.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
+dependencies = [
+ "autocfg",
 ]
 
 [[package]]
@@ -288,6 +444,15 @@ version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
 
+[[package]]
+name = "ppv-lite86"
+version = "0.2.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "85eae3c4ed2f50dcfe72643da4befc30deadb458a9b590d720cde2f2b1e97da9"
+dependencies = [
+ "zerocopy 0.8.27",
+]
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.86"
@@ -297,6 +462,50 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "proptest"
+version = "1.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b45fcc2344c680f5025fe57779faef368840d0bd1f42f216291f0dc4ace4744"
+dependencies = [
+ "bit-set",
+ "bit-vec",
+ "bitflags",
+ "num-traits",
+ "rand",
+ "rand_chacha",
+ "rand_xorshift",
+ "regex-syntax",
+ "rusty-fork",
+ "tempfile",
+ "unarray",
+]
+
+[[package]]
+name = "pulldown-cmark"
+version = "0.13.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e9f068eba8e7071c5f9511831b44f32c740d5adf574e990f946ddb53db2f314e"
+dependencies = [
+ "bitflags",
+ "getopts",
+ "memchr",
+ "pulldown-cmark-escape",
+ "unicase",
+]
+
+[[package]]
+name = "pulldown-cmark-escape"
+version = "0.11.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "007d8adb5ddab6f8e3f491ac63566a7d5002cc7ed73901f72057943fa71ae1ae"
+
+[[package]]
+name = "quick-error"
+version = "1.2.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a1d01941d82fa2ab50be1e79e6714289dd7cde78eba4c074bc5a4374f650dfe0"
+
 [[package]]
 name = "quote"
 version = "1.0.36"
@@ -306,6 +515,56 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "5.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "69cdb34c158ceb288df11e18b4bd39de994f6657d83847bdffdbd7f346754b0f"
+
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
+[[package]]
+name = "rand"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ef1d0d795eb7d84685bca4f72f3649f064e6641543d3a8c415898726a57b41"
+dependencies = [
+ "rand_chacha",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_chacha"
+version = "0.9.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d3022b5f1df60f26e1ffddd6c66e8aa15de382ae63b3a0c1bfc0e4d3e3f325cb"
+dependencies = [
+ "ppv-lite86",
+ "rand_core",
+]
+
+[[package]]
+name = "rand_core"
+version = "0.9.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "76afc826de14238e6e8c374ddcc1fa19e374fd8dd986b0d2af0d02377261d83c"
+dependencies = [
+ "getrandom 0.3.4",
+]
+
+[[package]]
+name = "rand_xorshift"
+version = "0.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "513962919efc330f829edb2535844d1b912b0fbe2ca165d613e4e8788bb05a5a"
+dependencies = [
+ "rand_core",
+]
+
 [[package]]
 name = "ratatui"
 version = "0.27.0"
@@ -324,7 +583,7 @@ dependencies = [
  "strum_macros",
  "unicode-segmentation",
  "unicode-truncate",
- "unicode-width",
+ "unicode-width 0.1.13",
 ]
 
 [[package]]
@@ -342,17 +601,48 @@ version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bd283d9651eeda4b2a83a43c1c91b266c40fd76ecd39a50a8c630ae69dc72891"
 dependencies = [
- "getrandom",
+ "getrandom 0.2.15",
  "libredox",
  "thiserror",
 ]
 
+[[package]]
+name = "regex-syntax"
+version = "0.8.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d6f6ff9a378485b298a5286656da665ba74413d36db0979633275d2e708145d4"
+
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "rustversion"
 version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
+[[package]]
+name = "rusty-fork"
+version = "0.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cc6bf79ff24e648f6da1f8d1f011e9cac26491b619e6b9280f2b47f1774e6ee2"
+dependencies = [
+ "fnv",
+ "quick-error",
+ "tempfile",
+ "wait-timeout",
+]
+
 [[package]]
 name = "ryu"
 version = "1.0.18"
@@ -398,13 +688,10 @@ dependencies = [
 ]
 
 [[package]]
-name = "serde_spanned"
-version = "0.6.8"
+name = "shlex"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87607cb1398ed59d48732e575a4c28a7a8ebf2454b964fe3f224f2afc07909e1"
-dependencies = [
- "serde",
-]
+checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"
 
 [[package]]
 name = "signal-hook"
@@ -491,6 +778,19 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom 0.4.3",
+ "once_cell",
+ "rustix",
+ "windows-sys 0.61.2",
+]
+
 [[package]]
 name = "thiserror"
 version = "1.0.63"
@@ -512,48 +812,37 @@ dependencies = [
 ]
 
 [[package]]
-name = "toml"
-version = "0.8.19"
+name = "tui-input"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a1ed1f98e3fdc28d6d910e6737ae6ab1a93bf1985935a1193e68f93eeb68d24e"
+checksum = "9b02e86628a225c39b2602863f244a01668184149928ceb410e47a8022d7597e"
 dependencies = [
- "serde",
- "serde_spanned",
- "toml_datetime",
- "toml_edit",
+ "crossterm",
+ "unicode-width 0.1.13",
 ]
 
 [[package]]
-name = "toml_datetime"
-version = "0.6.8"
+name = "tui-textarea"
+version = "0.5.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41"
+checksum = "00524c1366ee838839dd327d1f339ff51846ad4ea85bfa1332859e79adec612c"
 dependencies = [
- "serde",
+ "crossterm",
+ "ratatui",
+ "unicode-width 0.1.13",
 ]
 
 [[package]]
-name = "toml_edit"
-version = "0.22.22"
+name = "unarray"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ae48d6208a266e853d946088ed816055e556cc6028c5e8e2b84d9fa5dd7c7f5"
-dependencies = [
- "indexmap",
- "serde",
- "serde_spanned",
- "toml_datetime",
- "winnow",
-]
+checksum = "eaea85b334db583fe3274d12b4cd1880032beab409c0d774be044d4480ab9a94"
 
 [[package]]
-name = "tui-input"
-version = "0.9.0"
+name = "unicase"
+version = "2.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b02e86628a225c39b2602863f244a01668184149928ceb410e47a8022d7597e"
-dependencies = [
- "crossterm",
- "unicode-width",
-]
+checksum = "dbc4bc3a9f746d862c45cb89d705aa10f187bb96c76001afab07a0d35ce60142"
 
 [[package]]
 name = "unicode-ident"
@@ -575,7 +864,7 @@ checksum = "b3644627a5af5fa321c95b9b235a72fd24cd29c648c2c379431e6628655627bf"
 dependencies = [
  "itertools",
  "unicode-segmentation",
- "unicode-width",
+ "unicode-width 0.1.13",
 ]
 
 [[package]]
@@ -584,18 +873,87 @@ version = "0.1.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0336d538f7abc86d282a4189614dfaa90810dfc2c6f6427eaf88e16311dd225d"
 
+[[package]]
+name = "unicode-width"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4ac048d71ede7ee76d585517add45da530660ef4390e49b098733c6e897f254"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
+[[package]]
+name = "wait-timeout"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ac3b126d3914f9849036f826e054cbabdc8519970b8998ddaf3b5bd3c65f11"
+dependencies = [
+ "libc",
+]
+
 [[package]]
 name = "wasi"
 version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "wasip2"
+version = "1.0.4+wasi-0.2.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b67efb37e106e55ce722a510d6b5f9c17f083e5fc79afc2badeb12cc313d9487"
+dependencies = [
+ "wit-bindgen",
+]
+
+[[package]]
+name = "wasm-bindgen"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "64024a30ec1e37399cf85a7ffefebdb72205ca1c972291c51512360d90bd8566"
+dependencies = [
+ "cfg-if",
+ "once_cell",
+ "rustversion",
+ "wasm-bindgen-macro",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-macro"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "008b239d9c740232e71bd39e8ef6429d27097518b6b30bdf9086833bd5b6d608"
+dependencies = [
+ "quote",
+ "wasm-bindgen-macro-support",
+]
+
+[[package]]
+name = "wasm-bindgen-macro-support"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5256bae2d58f54820e6490f9839c49780dff84c65aeab9e772f15d5f0e913a55"
+dependencies = [
+ "bumpalo",
+ "proc-macro2",
+ "quote",
+ "syn",
+ "wasm-bindgen-shared",
+]
+
+[[package]]
+name = "wasm-bindgen-shared"
+version = "0.2.108"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f01b580c9ac74c8d8f0c0e4afb04eeef2acf145458e52c03845ee9cd23e3d12"
+dependencies = [
+ "unicode-ident",
+]
+
 [[package]]
 name = "winapi"
 version = "0.3.9"
@@ -618,6 +976,65 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
 
+[[package]]
+name = "windows-core"
+version = "0.62.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b8e83a14d34d0623b51dce9581199302a221863196a1dde71a7663a4c2be9deb"
+dependencies = [
+ "windows-implement",
+ "windows-interface",
+ "windows-link",
+ "windows-result",
+ "windows-strings",
+]
+
+[[package]]
+name = "windows-implement"
+version = "0.60.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "053e2e040ab57b9dc951b72c264860db7eb3b0200ba345b4e4c3b14f67855ddf"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-interface"
+version = "0.59.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3f316c4a2570ba26bbec722032c4099d8c8bc095efccdc15688708623367e358"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-result"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7781fa89eaf60850ac3d2da7af8e5242a5ea78d1a11c49bf2910bb5a73853eb5"
+dependencies = [
+ "windows-link",
+]
+
+[[package]]
+name = "windows-strings"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7837d08f69c77cf6b07689544538e017c1bfcf57e34b4c0ff58e6c2cd3b37091"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-sys"
 version = "0.48.0"
@@ -627,6 +1044,15 @@ dependencies = [
  "windows-targets 0.48.5",
 ]
 
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
+]
+
 [[package]]
 name = "windows-targets"
 version = "0.48.5"
@@ -749,13 +1175,10 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
 
 [[package]]
-name = "winnow"
-version = "0.6.20"
+name = "wit-bindgen"
+version = "0.57.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c1fec1a2bb5866f07c25f68c26e565c4c200aebb96d7e55710c19d3e8ac49b"
-dependencies = [
- "memchr",
-]
+checksum = "1ebf944e87a7c253233ad6766e082e3cd714b5d03812acc24c318f549614536e"
 
 [[package]]
 name = "zerocopy"
@@ -763,7 +1186,16 @@ version = "0.7.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1b9b4fd18abc82b8136838da5d50bae7bdea537c574d8dc1a34ed098d6c166f0"
 dependencies = [
- "zerocopy-derive",
+ "zerocopy-derive 0.7.35",
+]
+
+[[package]]
+name = "zerocopy"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0894878a5fa3edfd6da3f88c4805f4c8558e2b996227a3d864f47fe11e38282c"
+dependencies = [
+ "zerocopy-derive 0.8.27",
 ]
 
 [[package]]
@@ -776,3 +1208,14 @@ dependencies = [
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.8.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88d2b8d9c68ad2b9e4340d7832716a4d21a22a1154777ad56ea55c51a9cf3831"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 0c06b5f..4c74069 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "basilk"
-version = "0.2.1"
+version = "0.2.28"
 edition = "2021"
 description = "A Terminal User Interface (TUI) to manage your tasks with minimal kanban logic"
 license = "MIT OR Apache-2.0"
@@ -12,12 +12,22 @@ keywords = ["tui", "kanban", "tasks", "ratatui", "terminal"]
 categories = ["command-line-utilities"]
 default-run = "basilk"
 
+[features]
+# Opt-in performance benchmarks: `./scripts/bench.sh`
+bench = []
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+chrono = "0.4.43"
 dirs = "5.0.1"
+pulldown-cmark = "0.13.4"
 ratatui = "0.27.0"
 serde = { version = "1.0.204", features = ["derive"] }
 serde_json = "1.0.122"
-toml = "0.8.19"
 tui-input = "0.9.0"
+tui-textarea = "0.5"
+
+[dev-dependencies]
+proptest = "1.5"
+tempfile = "3.10"
diff --git a/README.md b/README.md
index 61133f6..3bf1717 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1,8 @@
 <p align="center"><img src="./assets/basil-k.jpg" width=240></img></p>
 <p align="center"><i>illustration generated using <a href="https://perchance.org/ai-pixel-art-generator">perchance.org</a></i></p>
 
+<p align="center">English | <a href="./README.zh-CN.md">中文</a></p>
+
 <h1 align="center">basilk</h1>
 <p align="center">A Terminal User Interface (TUI) to manage your tasks with minimal kanban logic</p>
 
@@ -36,49 +38,59 @@ Windows
 ```
 The choice to use the JSON format is to make easier to export
 
-## Installation
-### Cargo
-
-from [crates.io](https://crates.io/crates/basilk) using [`cargo`](https://doc.rust-lang.org/cargo/)
-
-```sh
-cargo install basilk
-```
-
-### AUR
-
-from the [AUR](https://aur.archlinux.org/packages/basilk) with using an [AUR helper](https://wiki.archlinux.org/title/AUR_helpers).
-
-```sh
-paru -S basilk
-```
-
-### Homebrew
-from a [homebrew tap](https://docs.brew.sh/Taps) using [`brew`](https://brew.sh/)
+This is a fork of the original [basilk](https://github.com/GabAlpha/basilk) project. For the original version, please refer to the upstream repository.
 
-```sh
-brew tap GabAlpha/tap
-brew install basilk
-```
-
-### X-CMD
-from a [x install](https://x-cmd.com/install/basilk) using [x-cmd](https://x-cmd.com)
+## Installation
 
 ```sh
-x install basilk
+git clone https://github.com/LiuYinCarl/basilk && cd basilk
+cargo install --path .
 ```
 
-### Build from source
-
-1. Clone the repository
-```sh
-git clone https://github.com/GabAlpha/basilk && cd basilk
-```
-2. Build
-```sh
-cargo build --release
-```
-Binary will be located at `target/release/basilk`
+Prebuilt binaries for Linux, macOS (Intel & Apple Silicon) and Windows are
+attached to every [GitHub Release](https://github.com/LiuYinCarl/basilk/releases).
+
+## Versioning & Releases
+
+Basilk follows [Semantic Versioning](https://semver.org/) (`MAJOR.MINOR.PATCH`,
+stored in `Cargo.toml`). Releases are **tag-driven** — pushing the `vX.Y.Z`
+tag triggers the [Release workflow](.github/workflows/release.yml) to build
+and publish.
+
+**Every code change must bump the version in the same commit** — a code
+commit without a version bump can never become a release, so this is
+enforced for you:
+
+- A `pre-commit` hook blocks code commits that don't bump the version
+  (code = `src/`, `tests/`, `Cargo.toml`, `Cargo.lock`). Enable the repo
+  hooks once per clone:
+  ```sh
+  ./scripts/install-hooks.sh
+  ```
+- A CI check (`version-bump` job) fails any push/PR that changes code
+  without bumping the version.
+
+The flow with hooks enabled:
+
+1. Make your code changes, then bump the version (updates `Cargo.toml` +
+   `Cargo.lock` in the working tree):
+   ```sh
+   ./scripts/bump-version.sh patch   # or minor / major
+   ```
+2. Stage everything and commit — the `post-commit` hook creates the
+   `vX.Y.Z` tag automatically.
+3. Push — the tag triggers the release build:
+   ```sh
+   git push origin master --tags
+   ```
+
+The workflow then builds binaries for Linux, macOS (Intel & Apple Silicon)
+and Windows, attaches them to a GitHub Release with auto-generated notes,
+and verifies the tag matches the version in `Cargo.toml` (it fails otherwise,
+so release binaries always report the tagged version).
+
+The manual **Run workflow** button can re-publish an existing tag (e.g. after
+a CI fix); it takes the tag name as input.
 
 ## Usage
 Run
@@ -86,7 +98,121 @@ Run
 ```sh
 basilk
 ```
-All available commands are displayed inside
+
+## Keybindings
+
+Press `h` to view the keybinding list in-app.
+
+### Global
+| Key | Action |
+|---|---|
+| `q` | Quit |
+
+### Project List View
+| Key | Action |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | Navigate projects |
+| `Enter`  `→`  `l` | Enter project (view tasks) |
+| `m` | Open notes |
+| `n` | New project |
+| `r` | Rename selected project |
+| `d` | Delete selected project |
+| `c` | Pomodoro (countdown) timer |
+| `h` | Help |
+
+### Task List View
+| Key | Action |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | Navigate tasks |
+| `←` `→` | Switch lane (board view) |
+| `b` | Toggle board / list view |
+| `Esc`  `←` | Back to project list |
+| `Enter` | Change task status |
+| `p` | Change task priority |
+| `n` | New task |
+| `r` | Rename selected task |
+| `v` | View task details |
+| `e` | Edit task note |
+| `d` | Delete selected task |
+| `t` | Toggle show/hide completed tasks |
+| `s` | Stopwatch timer for selected task |
+| `c` | Pomodoro (countdown) timer |
+| `h` | Help |
+
+### Change Status / Priority Modals
+| Key | Action |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | Navigate options |
+| `Enter` | Confirm selection |
+| `Esc` | Cancel |
+
+### Input Modals (New / Rename / Edit Note)
+| Key | Action |
+|---|---|
+| `Enter` | Confirm |
+| `Esc` | Cancel |
+
+### Delete Confirmation Modals
+| Key | Action |
+|---|---|
+| `y` | Confirm delete |
+| `n` | Cancel |
+
+### Task Details View
+| Key | Action |
+|---|---|
+| `e` | Edit task note |
+| `g` | Edit estimated time (hours, `0` = no estimate) |
+| Any other key | Close details |
+
+### Timer View
+| Key | Action |
+|---|---|
+| `Space` | Pause / resume |
+| `Enter` | Stop (a stopwatch saves its elapsed time to the bound task) |
+| `Esc` | Close (timer keeps running in the background) |
+
+### Notes List View
+| Key | Action |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | Navigate notes |
+| `Enter`  `→`  `l`  `v` | Open the note preview |
+| `n` | New note |
+| `r` | Rename selected note |
+| `d` | Delete selected note |
+| `Esc`  `←` | Back to project list |
+| `h` | Help |
+
+### Note Preview View
+| Key | Action |
+|---|---|
+| `↑` `↓`  `k` `j` | Scroll |
+| `PageUp` `PageDown` | Page up / down |
+| `g`  `G` | Top / bottom |
+| `e` | Edit (Markdown source) |
+| `Esc`  `Enter` | Back to notes list |
+| `h` | Help |
+
+### Note Editor View
+| Key | Action |
+|---|---|
+| `Esc` | Save and return to the preview |
+| Any other key | Editing (multi-line, handled by the editor) |
+
+The timer keeps running while you navigate (even back to the project list); it stops when you press `Enter` in the timer view or when you quit.
+
+- **Stopwatch** (`s`, task list): bound to the selected task; the elapsed time accumulates into the task's **Time Spent**, shown in the details view next to the task's **Estimate** (how long you expect the task to take, editable per task with `g`; the details view shows what percentage of the estimate has been spent).
+- **Pomodoro** (`c`, both views): a global countdown for focus sessions; at zero it rings the terminal bell and stays on screen (showing `time's up!`) until you press any key. It is not tied to any task, so nothing is accumulated.
+
+Tasks are displayed as `[Status] Title` with optional `[Priority]` prefix and, for tasks with an estimate set, a `[x%]` suffix showing how much of the estimate has been spent (red once it reaches 100%).
+- Statuses: **UpNext** (magenta), **OnGoing** (yellow), **Done** (green, ~~crossed out~~)
+- Priorities: `!` (highest), `!!` (high), `!!!` (low)
+
+Completed tasks are **hidden by default** in the task list view. Press `t` to toggle their visibility.
+
+Press `b` in the task list view to switch to a kanban **board view**: three vertical lanes (**Up Next** / **On Going** / **Done**), each titled with its task count, the focused lane highlighted in its status color. Use `←`/`→` to move between lanes and `↑`/`↓` to select a task within a lane; every other shortcut (`v` details, `Enter` status, `p` priority, timers, …) works the same, and changing a task's status moves it to the matching lane. The board always shows the Done lane, regardless of the `t` setting (which is a no-op while the board is active).
+
+Press `m` in the project list view to open **notes**: global, project-independent memos. A note is a titled entry whose body is Markdown; opening one shows a full-page rendered preview (headings, bold/italic, code blocks, lists, quotes, links), and `e` switches to a full-page multi-line editor for the Markdown source (`Esc` saves and returns to the preview).
 
 ## Contributing
 > [!NOTE]  
@@ -94,6 +220,10 @@ All available commands are displayed inside
 
 As I mentioned above, this is my first project in Rust, so contributions and help are welcome! If you have any suggestions, improvements, or bug fixes, feel free to submit a pull request or open a new issue.
 
+### Testing & coverage
+
+The test suite runs with `cargo test` and includes property tests (`src/property_tests.rs`). Coverage is measured with [cargo-llvm-cov](https://github.com/taiki-e/cargo-llvm-cov) (`cargo llvm-cov --workspace`) and enforced in CI (`--fail-under-lines 95`); the suite currently sits around **99.5% line coverage** — the only uncovered lines are the real-terminal glue in `main.rs` (`main`, `init_terminal`, `restore_terminal`, `CrosstermSource::next_key`), which cannot run inside a unit test. The full event loop, every view mode, and every key handler are exercised in-process via synthetic events and a `TestBackend`.
+
 ## License
 
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat&logo=GitHub&labelColor=1D272B&color=819188&logoColor=white)](./LICENSE-MIT)
diff --git a/README.zh-CN.md b/README.zh-CN.md
new file mode 100644
index 0000000..7adae67
--- /dev/null
+++ b/README.zh-CN.md
@@ -0,0 +1,183 @@
+<p align="center"><img src="./assets/basil-k.jpg" width=240></img></p>
+<p align="center"><i>插画由 <a href="https://perchance.org/ai-pixel-art-generator">perchance.org</a> 生成</i></p>
+
+<p align="center"><a href="./README.md">English</a> | 中文</p>
+
+<h1 align="center">basilk</h1>
+<p align="center">一个基于终端界面 (TUI) 的任务管理工具，具有简洁的看板逻辑</p>
+
+<img src="./assets/basilk.gif"></img>
+
+## 缘起
+那是一个[炎热的八月夜晚](https://www.meteo.it/notizie/meteo-caldo-in-aumento-la-tendenza-verso-ferragosto-c95aa7dc)，我正在整理待办事项，突然觉得需要一个简单、便携的软件来帮助我。**basilk** 由此诞生——既是一个学习 Rust 的暑期项目，也能在任何地方使用。
+
+名字 [_/ˈbæzəlkeɪ/_](https://gabalpha.github.io/read-audio/?p=https://github.com/GabAlpha/basilk/raw/master/assets/basil-k.wav) 源于罗勒（basil）——一种易于种植和维护的植物，而 "k" 代表看板（kanban）。
+
+<details>
+<summary>另一个故事</summary>
+
+<p align="center"><img src="./assets/bas-silk.jpg" width=240></img></p>
+<p align="center"><i>插画由 <a href="https://perchance.org/ai-pixel-art-generator">perchance.org</a> 生成</i></p>
+
+名字 [_/ˈbæzsɪlk/_](https://gabalpha.github.io/read-audio/?p=https://github.com/GabAlpha/basilk/raw/master/assets/bas-silk.wav) 源自 basil 与 silk 的结合，象征其制作过程的精巧。
+</details>
+
+## 关于
+**basilk** 以项目为单位组织任务，每个项目内的任务可设置不同的状态（Up Next / On Going / Done）。
+
+数据以 `.json` 格式存储，文件位于：
+```
+Linux
+~/.config/basilk
+
+macOS
+~/Library/Application Support/basilk
+
+Windows
+<USER>\AppData\Roaming\basilk
+```
+选择 JSON 格式是为了方便导出。
+
+本项目是原始 [basilk](https://github.com/GabAlpha/basilk) 的一个 fork 版本。如需原始版本，请参考上游仓库。
+
+## 安装
+
+```sh
+git clone https://github.com/LiuYinCarl/basilk && cd basilk
+cargo install --path .
+```
+
+## 使用
+运行
+
+```sh
+basilk
+```
+
+## 快捷键
+
+在应用内按 `h` 即可查看快捷键列表。
+
+### 全局
+| 按键 | 功能 |
+|---|---|
+| `q` | 退出 |
+
+### 项目列表视图
+| 按键 | 功能 |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | 浏览项目 |
+| `Enter`  `→`  `l` | 进入项目（查看任务） |
+| `m` | 打开便签 |
+| `n` | 新建项目 |
+| `r` | 重命名所选项目 |
+| `d` | 删除所选项目 |
+| `c` | 番茄钟（倒计时） |
+| `h` | 帮助 |
+
+### 任务列表视图
+| 按键 | 功能 |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | 浏览任务 |
+| `←` `→` | 切换泳道（看板视图） |
+| `b` | 切换看板 / 列表视图 |
+| `Esc`  `←` | 返回项目列表 |
+| `Enter` | 更改任务状态 |
+| `p` | 更改任务优先级 |
+| `n` | 新建任务 |
+| `r` | 重命名所选任务 |
+| `v` | 查看任务详情 |
+| `e` | 编辑任务备注 |
+| `d` | 删除所选任务 |
+| `t` | 切换显示/隐藏已完成任务 |
+| `s` | 所选任务的正向计时器 |
+| `c` | 番茄钟（倒计时） |
+| `h` | 帮助 |
+
+### 更改状态 / 优先级弹窗
+| 按键 | 功能 |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | 浏览选项 |
+| `Enter` | 确认选择 |
+| `Esc` | 取消 |
+
+### 输入弹窗（新建 / 重命名 / 编辑备注）
+| 按键 | 功能 |
+|---|---|
+| `Enter` | 确认 |
+| `Esc` | 取消 |
+
+### 删除确认弹窗
+| 按键 | 功能 |
+|---|---|
+| `y` | 确认删除 |
+| `n` | 取消 |
+
+### 任务详情视图
+| 按键 | 功能 |
+|---|---|
+| `e` | 编辑任务备注 |
+| `g` | 编辑预期时长（小时，`0` = 不设预期） |
+| 任意其他按键 | 关闭详情 |
+
+### 计时器视图
+| 按键 | 功能 |
+|---|---|
+| `Space` | 暂停 / 继续 |
+| `Enter` | 停止（正向计时会把时长累计到绑定的任务） |
+| `Esc` | 关闭（计时器在后台继续运行） |
+
+### 便签列表视图
+| 按键 | 功能 |
+|---|---|
+| `↑` `↓`  `k` `j`  `Tab` `Shift+Tab` | 浏览便签 |
+| `Enter`  `→`  `l`  `v` | 打开便签预览 |
+| `n` | 新建便签 |
+| `r` | 重命名所选便签 |
+| `d` | 删除所选便签 |
+| `Esc`  `←` | 返回项目列表 |
+| `h` | 帮助 |
+
+### 便签预览视图
+| 按键 | 功能 |
+|---|---|
+| `↑` `↓`  `k` `j` | 滚动 |
+| `PageUp` `PageDown` | 翻页 |
+| `g`  `G` | 顶部 / 底部 |
+| `e` | 编辑（Markdown 源码） |
+| `Esc`  `Enter` | 返回便签列表 |
+| `h` | 帮助 |
+
+### 便签编辑视图
+| 按键 | 功能 |
+|---|---|
+| `Esc` | 保存并返回预览 |
+| 其他按键 | 多行编辑（由编辑器处理） |
+
+计时器在你切换视图（包括返回项目列表）时持续运行，只有在计时器视图按 `Enter` 停止、或退出程序时才会结算。
+
+- **正向计时**（`s`，任务列表）：绑定所选任务，计时累计到任务的**累计时长**，在详情视图中与任务的**预期时长**（你预计这个任务要做多久，可按 `g` 为每个任务单独设置）并列展示，并显示已消耗预期时长的百分比。
+- **番茄钟**（`c`，两个视图均可）：全局倒计时，用于专注时段；归零时响铃提醒，界面停留在结束状态（显示“时间到！”），按任意键关闭。不关联任何任务，也不累计时长。
+
+任务以 `[状态] 标题` 格式显示，可选 `[优先级]` 前缀；设置了预期时长的任务还会带上 `[x%]` 后缀，显示已消耗预期时长的百分比（达到 100% 后变红）。
+- 状态：**UpNext**（品红）、**OnGoing**（黄色）、**Done**（绿色，~~删除线~~）
+- 优先级：`!`（最高）、`!!`（高）、`!!!`（低）
+
+已完成的任务在任务列表视图中**默认隐藏**，按 `t` 可切换显示。
+
+在任务列表视图按 `b` 可切换到看板**泳道视图**：三条竖排泳道（**Up Next** / **On Going** / **Done**），标题带任务计数，当前聚焦的泳道以其状态颜色高亮边框。用 `←`/`→` 在泳道间切换，`↑`/`↓` 在泳道内选择任务；其余快捷键（`v` 详情、`Enter` 状态、`p` 优先级、计时器等）照常工作，更改任务状态后任务会移动到对应泳道。看板始终显示 Done 泳道，不受 `t` 设置影响（看板模式下 `t` 无操作）。
+
+在项目列表视图按 `m` 可打开**便签**：全局的、不依附于项目的备忘录。便签由标题和 Markdown 正文组成，打开后进入整页渲染预览（标题、粗体/斜体、代码块、列表、引用、链接等），按 `e` 切换到整页多行编辑器修改 Markdown 源码，`Esc` 保存并返回预览。
+
+## 参与贡献
+> [!NOTE]
+> 本项目目前处于 beta 阶段，可能存在 bug。
+
+如上所述，这是我的第一个 Rust 项目，欢迎任何形式的贡献和帮助！如果你有任何建议、改进或 bug 修复，欢迎提交 pull request 或提出新的 issue。
+
+## 许可证
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg?style=flat&logo=GitHub&labelColor=1D272B&color=819188&logoColor=white)](./LICENSE-MIT)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=flat&logo=GitHub&labelColor=1D272B&color=819188&logoColor=white)](./LICENSE-APACHE)
+
+根据您的选择，许可协议为 [Apache License Version 2.0](./LICENSE-APACHE) 或 [The MIT License](./LICENSE-MIT)。
diff --git a/proptest-regressions/property_tests.txt b/proptest-regressions/property_tests.txt
new file mode 100644
index 0000000..c3c2716
--- /dev/null
+++ b/proptest-regressions/property_tests.txt
@@ -0,0 +1,7 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 7739710e9b2ca992bc3ead3dbb2de2e7a1f2c7cd67afefb11cb3ce5310111781 # shrinks to tasks = [Task { title: "", status: "UpNext", priority: 0, created_at: None, completed_at: None, note: "", time_spent_secs: 0, estimated_hours: 5124095576030432 }], hide_done = false, selected = 0
diff --git a/scripts/bench.sh b/scripts/bench.sh
new file mode 100755
index 0000000..6d42711
--- /dev/null
+++ b/scripts/bench.sh
@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+#
+# Run the opt-in performance benchmarks (release build, timing printed).
+#
+# Usage: ./scripts/bench.sh
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+cargo test --release --features bench --bin basilk perf_tests -- --ignored --nocapture
diff --git a/scripts/bump-version.sh b/scripts/bump-version.sh
new file mode 100755
index 0000000..55844bd
--- /dev/null
+++ b/scripts/bump-version.sh
@@ -0,0 +1,65 @@
+#!/usr/bin/env bash
+#
+# Bump the semantic version of the crate in Cargo.toml + Cargo.lock.
+# The files are edited in the working tree only — nothing is committed
+# or tagged here.
+#
+# Usage:
+#   ./scripts/bump-version.sh [patch|minor|major]
+#
+#   patch (default): 0.2.1 -> 0.2.2
+#   minor:           0.2.1 -> 0.3.0
+#   major:           0.2.1 -> 1.0.0
+#
+# Flow: the pre-commit hook (see .githooks/) requires every code commit
+# to include a version bump, so run this while preparing your commit,
+# stage everything together, and commit. The post-commit hook then
+# creates the vX.Y.Z tag automatically; pushing it triggers the CI
+# release pipeline (.github/workflows/release.yml).
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+BUMP="${1:-patch}"
+case "$BUMP" in
+  patch | minor | major) ;;
+  *) echo "usage: $0 [patch|minor|major]" >&2; exit 1 ;;
+esac
+
+CURRENT="$(grep -m1 '^version = ' Cargo.toml | sed 's/version = "\(.*\)"/\1/')"
+MAJOR="$(echo "$CURRENT" | cut -d. -f1)"
+MINOR="$(echo "$CURRENT" | cut -d. -f2)"
+PATCH="$(echo "$CURRENT" | cut -d. -f3)"
+
+case "$BUMP" in
+  major) MAJOR=$((MAJOR + 1)); MINOR=0; PATCH=0 ;;
+  minor) MINOR=$((MINOR + 1)); PATCH=0 ;;
+  patch) PATCH=$((PATCH + 1)) ;;
+esac
+
+NEW="$MAJOR.$MINOR.$PATCH"
+
+if [ -n "$(git tag -l "v$NEW")" ]; then
+  echo "error: tag v$NEW already exists" >&2
+  exit 1
+fi
+
+python3 - <<EOF
+import re
+
+# Cargo.toml: bump the package version
+path = "Cargo.toml"
+s = open(path).read()
+s = re.sub(r'^version = \"[^\"]+\"', 'version = "$NEW"', s, count=1, flags=re.M)
+open(path, "w").write(s)
+
+# Cargo.lock: keep the root package version in sync
+path = "Cargo.lock"
+s = open(path).read()
+s = re.sub(r'(name = "basilk"\nversion = ")[^"]+', r'\g<1>$NEW', s, count=1)
+open(path, "w").write(s)
+EOF
+
+echo "bumped $CURRENT -> $NEW"
+echo "next: stage Cargo.toml + Cargo.lock together with your code changes and commit"
+echo "(the post-commit hook tags v$NEW; pushing the tag triggers the release pipeline)"
diff --git a/scripts/install-hooks.sh b/scripts/install-hooks.sh
new file mode 100755
index 0000000..1235d1f
--- /dev/null
+++ b/scripts/install-hooks.sh
@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+#
+# Point git at the repository-managed hooks in .githooks/ (one-time
+# setup per clone):
+#
+#   pre-commit   block code commits that do not bump the crate version
+#   post-commit  auto-create the vX.Y.Z tag after a version-bump commit
+set -euo pipefail
+
+cd "$(dirname "$0")/.."
+
+git config core.hooksPath .githooks
+echo "git hooks enabled (core.hooksPath=.githooks)"
diff --git a/src/app.rs b/src/app.rs
new file mode 100644
index 0000000..bd727fa
--- /dev/null
+++ b/src/app.rs
@@ -0,0 +1,1490 @@
+use std::{error::Error, io};
+
+use ratatui::{
+    crossterm::event::{Event, KeyCode, KeyEvent, KeyEventKind},
+    prelude::*,
+    widgets::*,
+};
+use tui_input::{backend::crossterm::EventHandler, Input};
+use tui_textarea::TextArea;
+
+use crate::{
+    json::Json,
+    note::Note,
+    project::Project,
+    task::{Task, TASK_PRIORITIES, TASK_STATUSES},
+    timer::{TimerKind, TimerState},
+    util::Util,
+    view::View,
+};
+
+#[derive(Default, PartialEq, Debug)]
+pub(crate) enum ViewMode {
+    #[default]
+    ViewProjects,
+    RenameProject,
+    AddProject,
+    DeleteProject,
+
+    ViewTasks,
+    RenameTask,
+    ChangeStatusTask,
+    ChangePriorityTask,
+    AddTask,
+    DeleteTask,
+    ViewTaskDetails,
+    EditTaskNote,
+    SetTaskEstimate,
+    TimerTask,
+    SetCountdown,
+    ViewHelp,
+
+    ViewNotes,
+    AddNote,
+    RenameNote,
+    DeleteNote,
+    ViewNote,
+    EditNote,
+
+    InfoMigration,
+}
+
+pub(crate) struct App {
+    // TODO: Better list state mgmt
+    pub(crate) selected_project_index: ListState,
+    pub(crate) selected_task_index: ListState,
+    pub(crate) selected_status_task_index: ListState,
+    pub(crate) selected_priority_task_index: ListState,
+    pub(crate) delete_confirm_index: ListState,
+    pub(crate) view_mode: ViewMode,
+    pub(crate) previous_view_mode: ViewMode,
+    pub(crate) projects: Vec<Project>,
+    pub(crate) hide_done_tasks: bool,
+    pub(crate) timer: Option<TimerState>,
+    /// When true, the task view renders as a three-lane kanban board
+    /// (Up Next / On Going / Done) instead of the classic list.
+    pub(crate) board_view: bool,
+    /// Currently focused board lane: index into `TASK_STATUSES`.
+    pub(crate) board_lane: usize,
+    /// Per-lane selection/scroll state for the board view.
+    pub(crate) board_lane_states: [ListState; 3],
+    /// Global notes, independent of projects.
+    pub(crate) notes: Vec<Note>,
+    pub(crate) selected_note_index: ListState,
+    /// Vertical scroll offset of the note preview page.
+    pub(crate) note_scroll: u16,
+    /// Editor state while `ViewMode::EditNote` is active.
+    pub(crate) note_textarea: Option<TextArea<'static>>,
+}
+
+/// What the event loop should do after a key press was handled.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum KeyAction {
+    /// No special action; continue the loop normally.
+    None,
+    /// Skip the rest of this iteration (mirrors the previous `continue`
+    /// inside the event loop: modal navigation and empty-list guards
+    /// redraw on the next iteration without ticking the timer).
+    Skip,
+    /// Quit the application; the caller settles the timer.
+    Quit,
+}
+
+/// Source of key events for the event loop. The production implementation
+/// reads from the terminal; tests inject a queue of synthetic events so the
+/// whole loop (draw, key dispatch, timer tick) runs in-process.
+pub(crate) trait KeySource {
+    fn next_key(&mut self) -> io::Result<Option<KeyEvent>>;
+}
+
+impl App {
+    pub(crate) fn setup() -> Result<Self, Box<dyn Error>> {
+        Ok(Self {
+            selected_project_index: ListState::default().with_selected(Some(0)),
+            selected_task_index: ListState::default().with_selected(Some(0)),
+            selected_status_task_index: ListState::default().with_selected(Some(0)),
+            selected_priority_task_index: ListState::default().with_selected(Some(0)),
+            delete_confirm_index: ListState::default().with_selected(Some(0)),
+            view_mode: ViewMode::default(),
+            previous_view_mode: ViewMode::default(),
+            projects: Json::read()?,
+            hide_done_tasks: true,
+            timer: None,
+            board_view: false,
+            board_lane: 0,
+            board_lane_states: [
+                ListState::default().with_selected(Some(0)),
+                ListState::default().with_selected(Some(0)),
+                ListState::default().with_selected(Some(0)),
+            ],
+            notes: Json::read_notes(),
+            selected_note_index: ListState::default().with_selected(Some(0)),
+            note_scroll: 0,
+            note_textarea: None,
+        })
+    }
+
+    /// Run the event loop against a `KeySource`. The production entry point
+    /// is `main` (with `CrosstermSource`); tests drive this method directly
+    /// with a queue of synthetic keys so the whole loop runs in-process.
+    pub(crate) fn run_with_source(
+        &mut self,
+        mut terminal: Terminal<impl Backend>,
+        were_applied_migrations: bool,
+        source: &mut impl KeySource,
+    ) -> io::Result<()> {
+        let mut input = Input::default();
+
+        let mut items: Vec<ListItem> = vec![];
+        Project::load_items(self, &mut items);
+
+        let mut status_items: Vec<ListItem> = vec![];
+        Task::load_statuses_items(&mut status_items);
+
+        let mut priority_items: Vec<ListItem> = vec![];
+        Task::load_priority_items(&mut priority_items);
+
+        if were_applied_migrations {
+            self.view_mode = ViewMode::InfoMigration
+        }
+
+        loop {
+            terminal.draw(|f| {
+                self.render(f, f.size(), &input, &items, &status_items, &priority_items)
+            })?;
+
+            if let Some(key) = source.next_key()? {
+                // Capture only the "Press" event to prevent double input on Windows
+                if key.kind == KeyEventKind::Press {
+                    match self.handle_key(
+                        key,
+                        &mut input,
+                        &mut items,
+                        &status_items,
+                        &priority_items,
+                    ) {
+                        KeyAction::Quit => {
+                            self.settle_timer();
+                            return Ok(());
+                        }
+                        KeyAction::Skip => continue,
+                        KeyAction::None => {}
+                    }
+                }
+            }
+
+            self.tick_timer();
+        }
+    }
+
+    /// Dispatch a pressed key to the handler of the current view mode.
+    ///
+    /// Each mode owns the keys it understands, so the event loop stays
+    /// shallow instead of nesting every binding in one giant `match`.
+    fn handle_key(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+        status_items: &[ListItem],
+        priority_items: &[ListItem],
+    ) -> KeyAction {
+        match self.view_mode {
+            ViewMode::ViewProjects => self.handle_view_projects(key, input, items),
+            ViewMode::RenameProject => self.handle_rename_project(key, input, items),
+            ViewMode::AddProject => self.handle_add_project(key, input, items),
+            ViewMode::DeleteProject => self.handle_delete_project(key, items),
+            ViewMode::ViewTasks => self.handle_view_tasks(key, input, items),
+            ViewMode::RenameTask => self.handle_rename_task(key, input, items),
+            ViewMode::ChangeStatusTask => self.handle_change_status_task(key, items, status_items),
+            ViewMode::ChangePriorityTask => {
+                self.handle_change_priority_task(key, items, priority_items)
+            }
+            ViewMode::AddTask => self.handle_add_task(key, input, items),
+            ViewMode::DeleteTask => self.handle_delete_task(key, items),
+            ViewMode::ViewTaskDetails => self.handle_view_task_details(key, input),
+            ViewMode::EditTaskNote => self.handle_edit_task_note(key, input, items),
+            ViewMode::SetTaskEstimate => self.handle_set_task_estimate(key, input, items),
+            ViewMode::TimerTask => self.handle_timer_task(key),
+            ViewMode::SetCountdown => self.handle_set_countdown(key, input),
+            ViewMode::ViewHelp => {
+                self.back_to_previous_view();
+                KeyAction::None
+            }
+            ViewMode::ViewNotes => self.handle_view_notes(key, input, items),
+            ViewMode::AddNote => self.handle_add_note(key, input, items),
+            ViewMode::RenameNote => self.handle_rename_note(key, input, items),
+            ViewMode::DeleteNote => self.handle_delete_note(key, items),
+            ViewMode::ViewNote => self.handle_view_note(key, items),
+            ViewMode::EditNote => self.handle_edit_note(key),
+            ViewMode::InfoMigration => {
+                self.change_view(ViewMode::ViewProjects);
+                KeyAction::None
+            }
+        }
+    }
+
+    fn handle_view_projects(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Char('h') => {
+                self.previous_view_mode = ViewMode::ViewProjects;
+                self.change_view(ViewMode::ViewHelp);
+            }
+            Enter | Right | Char('l') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                Task::load_items(self, items);
+                self.selected_task_index.select(Some(0));
+
+                // The sync inside `load_items` ran before the
+                // selection was reset to the top
+                if self.board_view {
+                    self.board_sync();
+                }
+
+                self.change_view(ViewMode::ViewTasks);
+            }
+            Char('r') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                *input = Input::default().with_value(Project::get_current(self).title.clone());
+
+                self.change_view(ViewMode::RenameProject);
+            }
+            Char('n') => {
+                input.reset();
+
+                self.change_view(ViewMode::AddProject);
+            }
+            Char('d') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                self.change_view(ViewMode::DeleteProject);
+            }
+            Down | Tab | Char('j') => {
+                self.next(items);
+            }
+            Up | BackTab | Char('k') => {
+                self.previous(items);
+            }
+            Char('c') => {
+                self.previous_view_mode = ViewMode::ViewProjects;
+
+                if self.timer.is_some() {
+                    self.change_view(ViewMode::TimerTask);
+                } else {
+                    input.reset();
+
+                    self.change_view(ViewMode::SetCountdown);
+                }
+            }
+            Char('m') => {
+                Note::load_items(self, items);
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            Char('q') => {
+                return KeyAction::Quit;
+            }
+            _ => {}
+        }
+        KeyAction::None
+    }
+
+    fn handle_rename_project(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                Project::rename(self, items, input.value());
+                input.reset();
+
+                self.change_view(ViewMode::ViewProjects);
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewProjects);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_add_project(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Esc => {
+                self.change_view(ViewMode::ViewProjects);
+            }
+            Enter => {
+                if !input.value().is_empty() {
+                    Project::create(self, items, input.value());
+                    self.selected_project_index
+                        .select(Some(self.projects.len() - 1));
+                }
+
+                self.change_view(ViewMode::ViewProjects);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_delete_project(&mut self, key: KeyEvent, items: &mut Vec<ListItem>) -> KeyAction {
+        if self.handle_modal_nav(
+            key.code,
+            &View::delete_confirm_items(),
+            ViewMode::ViewProjects,
+        ) {
+            return KeyAction::Skip;
+        }
+        if key.code == KeyCode::Enter {
+            if self.delete_confirm_index.selected() == Some(0) {
+                let deleted_index = self.selected_project_index.selected().unwrap();
+
+                Project::delete(self, items);
+                self.selected_project_index.select_previous();
+
+                // Keep the timer binding consistent: a timer on the
+                // deleted project is dropped, later indexes shift down
+                let bound_index = self
+                    .timer
+                    .as_ref()
+                    .and_then(|t| t.bound.as_ref())
+                    .map(|b| b.project_index);
+
+                if bound_index == Some(deleted_index) {
+                    self.timer = None;
+                } else if let Some(timer) = self.timer.as_mut() {
+                    if let Some(bound) = timer.bound.as_mut() {
+                        if bound.project_index > deleted_index {
+                            bound.project_index -= 1;
+                        }
+                    }
+                }
+            }
+            self.delete_confirm_index.select(Some(0));
+            self.change_view(ViewMode::ViewProjects);
+        }
+        KeyAction::None
+    }
+
+    fn handle_view_tasks(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        // In board mode the focused lane (not the list) decides
+        // whether task actions are available: the list can be
+        // empty only because done tasks are hidden, while the
+        // Done lane still shows them.
+        let no_current_task = if self.board_view {
+            self.board_lane_is_empty()
+        } else {
+            items.is_empty()
+        };
+
+        match key.code {
+            Char('h') => {
+                self.previous_view_mode = ViewMode::ViewTasks;
+                self.change_view(ViewMode::ViewHelp);
+            }
+            Esc => {
+                Project::load_items(self, items);
+
+                self.change_view(ViewMode::ViewProjects);
+            }
+            Left => {
+                if self.board_view {
+                    self.board_switch_lane(false);
+                } else {
+                    Project::load_items(self, items);
+
+                    self.change_view(ViewMode::ViewProjects);
+                }
+            }
+            Right => {
+                if self.board_view {
+                    self.board_switch_lane(true);
+                }
+            }
+            Char('b') => {
+                self.board_view = !self.board_view;
+
+                // Rebuild the item list: the board shows
+                // done tasks, the list view may hide them.
+                // When toggling on, `load_items` also
+                // re-syncs the board focus.
+                Task::load_items(self, items);
+            }
+            Enter => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                let index = TASK_STATUSES
+                    .into_iter()
+                    .position(|t| t == Task::get_current(self).status)
+                    .unwrap();
+
+                self.selected_status_task_index.select(Some(index));
+
+                self.change_view(ViewMode::ChangeStatusTask);
+            }
+            Char('p') => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                let index = TASK_PRIORITIES
+                    .into_iter()
+                    .position(|t| t == Task::get_current(self).priority)
+                    .unwrap();
+
+                self.selected_priority_task_index.select(Some(index));
+
+                self.change_view(ViewMode::ChangePriorityTask);
+            }
+            Char('r') => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                *input = Input::default().with_value(Task::get_current(self).title.clone());
+
+                self.change_view(ViewMode::RenameTask);
+            }
+            Char('n') => {
+                input.reset();
+
+                self.change_view(ViewMode::AddTask);
+            }
+            Char('d') => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                self.change_view(ViewMode::DeleteTask);
+            }
+            Char('v') => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                self.change_view(ViewMode::ViewTaskDetails);
+            }
+            Char('e') => {
+                if no_current_task {
+                    return KeyAction::Skip;
+                }
+
+                *input = Input::default().with_value(Task::get_current(self).note.clone());
+
+                self.change_view(ViewMode::EditTaskNote);
+            }
+            Down | Tab | Char('j') => {
+                if self.board_view {
+                    self.board_move(true);
+                } else {
+                    self.next(items);
+                }
+            }
+            Up | BackTab | Char('k') => {
+                if self.board_view {
+                    self.board_move(false);
+                } else {
+                    self.previous(items);
+                }
+            }
+            Char('t') => {
+                // The board always shows the Done lane, so there
+                // is nothing to toggle while it is active
+                if !self.board_view {
+                    self.hide_done_tasks = !self.hide_done_tasks;
+                    Task::load_items(self, items);
+                }
+            }
+            Char('s') => {
+                self.previous_view_mode = ViewMode::ViewTasks;
+
+                if self.timer.is_some() {
+                    self.change_view(ViewMode::TimerTask);
+                } else if !no_current_task {
+                    let project_index = self.selected_project_index.selected().unwrap();
+                    let task_title = Task::get_current(self).title.clone();
+
+                    self.timer = Some(TimerState::new_stopwatch(project_index, task_title));
+
+                    self.change_view(ViewMode::TimerTask);
+                }
+            }
+            Char('c') => {
+                self.previous_view_mode = ViewMode::ViewTasks;
+
+                if self.timer.is_some() {
+                    self.change_view(ViewMode::TimerTask);
+                } else {
+                    input.reset();
+
+                    self.change_view(ViewMode::SetCountdown);
+                }
+            }
+            Char('q') => {
+                return KeyAction::Quit;
+            }
+            _ => {}
+        }
+        KeyAction::None
+    }
+
+    fn handle_rename_task(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                let project_index = self.selected_project_index.selected().unwrap();
+                let old_title = Task::get_current(self).title.clone();
+                let new_title = input.value().to_string();
+
+                // A duplicate title is rejected: keep the input and stay in
+                // the rename view so the user can pick another name.
+                if !Task::rename(self, items, &new_title) {
+                    return KeyAction::None;
+                }
+                input.reset();
+
+                // Keep a running timer bound to the renamed task
+                if let Some(timer) = self.timer.as_mut() {
+                    if timer.is_bound_to(project_index, &old_title) {
+                        if let Some(bound) = timer.bound.as_mut() {
+                            bound.task_title = new_title;
+                        }
+                    }
+                }
+
+                self.change_view(ViewMode::ViewTasks);
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewTasks);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_change_status_task(
+        &mut self,
+        key: KeyEvent,
+        items: &mut Vec<ListItem>,
+        status_items: &[ListItem],
+    ) -> KeyAction {
+        if self.handle_modal_nav(key.code, status_items, ViewMode::ViewTasks) {
+            return KeyAction::Skip;
+        }
+        if key.code == KeyCode::Enter {
+            Task::change_status(
+                self,
+                items,
+                TASK_STATUSES[self.selected_status_task_index.selected().unwrap()],
+            );
+
+            self.selected_status_task_index.select(Some(0));
+            self.change_view(ViewMode::ViewTasks);
+        }
+        KeyAction::None
+    }
+
+    fn handle_change_priority_task(
+        &mut self,
+        key: KeyEvent,
+        items: &mut Vec<ListItem>,
+        priority_items: &[ListItem],
+    ) -> KeyAction {
+        if self.handle_modal_nav(key.code, priority_items, ViewMode::ViewTasks) {
+            return KeyAction::Skip;
+        }
+        if key.code == KeyCode::Enter {
+            Task::change_priority(
+                self,
+                items,
+                TASK_PRIORITIES[self.selected_priority_task_index.selected().unwrap()],
+            );
+
+            self.selected_priority_task_index.select(Some(0));
+            self.change_view(ViewMode::ViewTasks);
+        }
+        KeyAction::None
+    }
+
+    fn handle_add_task(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                // Empty and duplicate titles are rejected: keep the input
+                // and stay in the add view so nothing is silently dropped.
+                if Task::create(self, items, input.value()) {
+                    self.change_view(ViewMode::ViewTasks);
+                }
+            }
+            Esc => {
+                self.change_view(ViewMode::ViewTasks);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_delete_task(&mut self, key: KeyEvent, items: &mut Vec<ListItem>) -> KeyAction {
+        if self.handle_modal_nav(key.code, &View::delete_confirm_items(), ViewMode::ViewTasks) {
+            return KeyAction::Skip;
+        }
+        if key.code == KeyCode::Enter {
+            if self.delete_confirm_index.selected() == Some(0) {
+                // Drop a timer bound to the task being deleted
+                let project_index = self.selected_project_index.selected().unwrap();
+                let task_title = Task::get_current(self).title.clone();
+                let bound = matches!(
+                    self.timer.as_ref(),
+                    Some(t) if t.is_bound_to(project_index, &task_title)
+                );
+                if bound {
+                    self.timer = None;
+                }
+
+                self.delete_current_task(items);
+            }
+            self.delete_confirm_index.select(Some(0));
+            self.change_view(ViewMode::ViewTasks);
+        }
+        KeyAction::None
+    }
+
+    fn handle_view_task_details(&mut self, key: KeyEvent, input: &mut Input) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Char('e') => {
+                *input = Input::default().with_value(Task::get_current(self).note.clone());
+
+                self.change_view(ViewMode::EditTaskNote);
+            }
+            Char('g') => {
+                // Prefill the current estimate; an empty field
+                // is less friction than a "0" to delete first
+                let current = Task::get_current(self).estimated_hours;
+                *input = Input::default().with_value(if current > 0 {
+                    current.to_string()
+                } else {
+                    String::new()
+                });
+
+                self.change_view(ViewMode::SetTaskEstimate);
+            }
+            _ => {
+                self.change_view(ViewMode::ViewTasks);
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_edit_task_note(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                Task::update_note(self, items, input.value());
+                input.reset();
+
+                self.change_view(ViewMode::ViewTaskDetails);
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewTaskDetails);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_set_task_estimate(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                let raw = input.value().trim().to_string();
+
+                if let Ok(hours) = raw.parse::<u64>() {
+                    Task::update_estimate(self, items, hours);
+                    input.reset();
+
+                    self.change_view(ViewMode::ViewTaskDetails);
+                } else if raw.is_empty() {
+                    input.reset();
+
+                    self.change_view(ViewMode::ViewTaskDetails);
+                }
+                // Invalid non-empty input: stay in the modal
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewTaskDetails);
+            }
+            // Only digits make sense here
+            Char(c) if !c.is_ascii_digit() => {}
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_timer_task(&mut self, key: KeyEvent) -> KeyAction {
+        if self.timer.as_ref().is_some_and(TimerState::is_finished) {
+            // Finished countdown stays on screen; any key dismisses it
+            self.settle_timer();
+            self.back_to_previous_view();
+            return KeyAction::Skip;
+        }
+
+        use KeyCode::*;
+        match key.code {
+            Char(' ') => {
+                if let Some(timer) = self.timer.as_mut() {
+                    if timer.is_running() {
+                        timer.pause();
+                    } else {
+                        timer.resume();
+                    }
+                }
+            }
+            Enter => {
+                self.settle_timer();
+                self.back_to_previous_view();
+            }
+            Esc => {
+                self.back_to_previous_view();
+            }
+            _ => {}
+        }
+        KeyAction::None
+    }
+
+    fn handle_set_countdown(&mut self, key: KeyEvent, input: &mut Input) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                let raw = input.value().trim().to_string();
+                let minutes = raw.parse::<f64>().unwrap_or(0.0);
+                let secs = (minutes * 60.0).round() as u64;
+
+                if secs > 0 {
+                    input.reset();
+
+                    self.timer = Some(TimerState::new_countdown(secs));
+
+                    self.change_view(ViewMode::TimerTask);
+                } else if raw.is_empty() {
+                    input.reset();
+
+                    self.back_to_previous_view();
+                }
+                // Invalid non-empty input: stay in the modal
+            }
+            Esc => {
+                input.reset();
+
+                self.back_to_previous_view();
+            }
+            // Only digits and a decimal point make sense here
+            Char(c) if !c.is_ascii_digit() && c != '.' => {}
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_view_notes(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Char('h') => {
+                self.previous_view_mode = ViewMode::ViewNotes;
+                self.change_view(ViewMode::ViewHelp);
+            }
+            Esc | Left => {
+                Project::load_items(self, items);
+
+                self.change_view(ViewMode::ViewProjects);
+            }
+            Enter | Right | Char('l') | Char('v') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                self.note_scroll = 0;
+
+                self.change_view(ViewMode::ViewNote);
+            }
+            Char('n') => {
+                input.reset();
+
+                self.change_view(ViewMode::AddNote);
+            }
+            Char('r') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                *input = Input::default().with_value(Note::get_current(self).title.clone());
+
+                self.change_view(ViewMode::RenameNote);
+            }
+            Char('d') => {
+                if items.is_empty() {
+                    return KeyAction::Skip;
+                }
+
+                self.change_view(ViewMode::DeleteNote);
+            }
+            Down | Tab | Char('j') => {
+                self.next(items);
+            }
+            Up | BackTab | Char('k') => {
+                self.previous(items);
+            }
+            Char('q') => {
+                return KeyAction::Quit;
+            }
+            _ => {}
+        }
+        KeyAction::None
+    }
+
+    fn handle_add_note(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                if !input.value().is_empty() {
+                    Note::create(self, items, input.value());
+                    input.reset();
+
+                    self.selected_note_index
+                        .select(Some(self.notes.len().saturating_sub(1)));
+                }
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_rename_note(
+        &mut self,
+        key: KeyEvent,
+        input: &mut Input,
+        items: &mut Vec<ListItem>,
+    ) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Enter => {
+                Note::rename(self, items, input.value());
+                input.reset();
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            Esc => {
+                input.reset();
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            _ => {
+                input.handle_event(&Event::Key(key));
+            }
+        }
+        KeyAction::None
+    }
+
+    fn handle_delete_note(&mut self, key: KeyEvent, items: &mut Vec<ListItem>) -> KeyAction {
+        if self.handle_modal_nav(key.code, &View::delete_confirm_items(), ViewMode::ViewNotes) {
+            return KeyAction::Skip;
+        }
+        if key.code == KeyCode::Enter {
+            if self.delete_confirm_index.selected() == Some(0) {
+                Note::delete(self, items);
+            }
+            self.delete_confirm_index.select(Some(0));
+            self.change_view(ViewMode::ViewNotes);
+        }
+        KeyAction::None
+    }
+
+    /// Full-page Markdown preview: scroll keys adjust `note_scroll`
+    /// (clamped against the wrapped content height at render time).
+    fn handle_view_note(&mut self, key: KeyEvent, items: &mut Vec<ListItem>) -> KeyAction {
+        use KeyCode::*;
+        match key.code {
+            Char('h') => {
+                self.previous_view_mode = ViewMode::ViewNote;
+                self.change_view(ViewMode::ViewHelp);
+            }
+            Char('e') => {
+                let body = Note::get_current(self).body.clone();
+                let mut lines: Vec<String> = body.lines().map(|l| l.to_string()).collect();
+                if lines.is_empty() {
+                    lines.push(String::new());
+                }
+
+                let mut textarea = TextArea::from(lines);
+                textarea.set_block(Block::bordered().title(" Edit Note — Esc: save & back "));
+                self.note_textarea = Some(textarea);
+
+                self.change_view(ViewMode::EditNote);
+            }
+            Down | Char('j') => {
+                self.note_scroll = self.note_scroll.saturating_add(1);
+            }
+            Up | Char('k') => {
+                self.note_scroll = self.note_scroll.saturating_sub(1);
+            }
+            PageDown => {
+                self.note_scroll = self.note_scroll.saturating_add(10);
+            }
+            PageUp => {
+                self.note_scroll = self.note_scroll.saturating_sub(10);
+            }
+            Home | Char('g') => {
+                self.note_scroll = 0;
+            }
+            End | Char('G') => {
+                // Clamped to the real bottom when rendering
+                self.note_scroll = u16::MAX;
+            }
+            Esc | Enter => {
+                // The body may have changed in the editor; refresh the
+                // list so the snippet is up to date
+                Note::load_items(self, items);
+
+                self.change_view(ViewMode::ViewNotes);
+            }
+            Char('q') => {
+                return KeyAction::Quit;
+            }
+            _ => {}
+        }
+        KeyAction::None
+    }
+
+    /// Full-page editor: every key except Esc goes to the textarea;
+    /// Esc saves the body and returns to the rendered preview.
+    fn handle_edit_note(&mut self, key: KeyEvent) -> KeyAction {
+        if key.code == KeyCode::Esc {
+            if let Some(textarea) = self.note_textarea.take() {
+                let body = textarea.into_lines().join("\n");
+                // Skip the write (and the `updated_at` bump) when nothing changed
+                if body != Note::get_current(self).body {
+                    Note::update_body(self, &body);
+                }
+            }
+
+            self.change_view(ViewMode::ViewNote);
+            return KeyAction::None;
+        }
+
+        if let Some(textarea) = self.note_textarea.as_mut() {
+            textarea.input(key);
+        }
+        KeyAction::None
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn render(
+        &mut self,
+        f: &mut Frame,
+        area: Rect,
+        input: &Input,
+        items: &[ListItem],
+        status_items: &[ListItem],
+        priority_items: &[ListItem],
+    ) {
+        let layout = Layout::vertical([
+            Constraint::Percentage(2),
+            Constraint::Percentage(96),
+            Constraint::Percentage(2),
+        ]);
+
+        let [header_area, main_area, hint_area] = layout.areas(area);
+
+        // Header
+        f.render_widget(
+            Paragraph::new(format!("::{}::", env!("CARGO_PKG_NAME"))).centered(),
+            header_area,
+        );
+
+        // Hint and timer readout
+        self.render_hint(f, hint_area);
+
+        // Main view: the note preview and editor take the whole main area
+        match self.view_mode {
+            ViewMode::ViewNote => View::show_note(self, f, main_area),
+            ViewMode::EditNote => View::show_note_editor(self, f, main_area),
+            _ => View::show_items(self, items, f, main_area),
+        }
+
+        // Modal on top of the current view, if any
+        self.render_modal(f, area, input, status_items, priority_items);
+    }
+
+    /// The hint line, plus the running timer readout (right aligned).
+    fn render_hint(&self, f: &mut Frame, hint_area: Rect) {
+        f.render_widget(
+            Paragraph::new(Line::from(Span::styled(
+                " h  help",
+                Style::default().fg(Color::Green),
+            ))),
+            hint_area,
+        );
+
+        if let Some(timer) = &self.timer {
+            let secs = match timer.kind {
+                TimerKind::Stopwatch => timer.elapsed().as_secs(),
+                TimerKind::Countdown => timer.remaining().unwrap_or_default().as_secs(),
+            };
+
+            let icon = match timer.kind {
+                TimerKind::Stopwatch => {
+                    if timer.is_running() {
+                        "▶"
+                    } else {
+                        "❚❚"
+                    }
+                }
+                TimerKind::Countdown => "▼",
+            };
+
+            let color = if !timer.is_running() {
+                Color::Yellow
+            } else if timer.kind == TimerKind::Countdown && secs <= 10 {
+                Color::Red
+            } else {
+                Color::Green
+            };
+
+            // Keep the readout short enough to not overlap the help hint
+            let label = match &timer.bound {
+                Some(bound) => {
+                    let title: String = bound.task_title.chars().take(20).collect();
+                    let ellipsis = if bound.task_title.chars().count() > 20 {
+                        "…"
+                    } else {
+                        ""
+                    };
+                    format!("{}{}", title, ellipsis)
+                }
+                None => "pomodoro".to_string(),
+            };
+
+            f.render_widget(
+                Paragraph::new(Line::from(Span::styled(
+                    format!("{} {} {}", icon, Util::format_secs(secs), label),
+                    Style::default().fg(color),
+                )))
+                .alignment(Alignment::Right),
+                hint_area,
+            );
+        }
+    }
+
+    /// Render the modal for the current view mode, if any.
+    fn render_modal(
+        &mut self,
+        f: &mut Frame,
+        area: Rect,
+        input: &Input,
+        status_items: &[ListItem],
+        priority_items: &[ListItem],
+    ) {
+        match self.view_mode {
+            ViewMode::InfoMigration => View::show_migration_info_modal(f, area),
+            ViewMode::AddTask | ViewMode::AddProject | ViewMode::AddNote => {
+                View::show_new_item_modal(f, area, input)
+            }
+            ViewMode::RenameTask | ViewMode::RenameProject | ViewMode::RenameNote => {
+                View::show_rename_item_modal(f, area, input)
+            }
+            ViewMode::EditTaskNote => View::show_edit_note_modal(f, area, input),
+            ViewMode::SetCountdown => View::show_countdown_modal(f, area, input),
+            ViewMode::SetTaskEstimate => View::show_task_estimate_modal(f, area, input),
+            ViewMode::TimerTask => View::show_timer_modal(self, f, area),
+            ViewMode::DeleteTask | ViewMode::DeleteProject | ViewMode::DeleteNote => {
+                View::show_delete_item_modal(self, f, area)
+            }
+            ViewMode::ChangeStatusTask => {
+                View::show_select_task_status_modal(self, status_items, f, area)
+            }
+            ViewMode::ChangePriorityTask => {
+                View::show_select_task_priority_modal(self, priority_items, f, area)
+            }
+            ViewMode::ViewHelp => View::show_help_modal(self, f, area),
+            ViewMode::ViewTaskDetails => View::show_task_details_modal(self, f, area),
+            _ => {}
+        }
+    }
+
+    fn next(&mut self, items: &[ListItem]) {
+        if items.is_empty() {
+            return;
+        }
+
+        let i = match self.use_state().selected() {
+            Some(i) => {
+                if i >= items.len() - 1 {
+                    0
+                } else {
+                    i + 1
+                }
+            }
+            None => 0,
+        };
+
+        self.use_state().select(Some(i))
+    }
+
+    fn previous(&mut self, items: &[ListItem]) {
+        if items.is_empty() {
+            return;
+        }
+
+        let i = match self.use_state().selected() {
+            Some(i) => {
+                if i == 0 {
+                    items.len() - 1
+                } else {
+                    i - 1
+                }
+            }
+            None => 0,
+        };
+
+        self.use_state().select(Some(i))
+    }
+
+    /// Delete the selected task, move the selection to the previous one,
+    /// and keep the board focus consistent with the action target
+    /// (`select_previous` runs after the sync inside `Task::load_items`,
+    /// so the board must be re-synced afterwards).
+    fn delete_current_task(&mut self, items: &mut Vec<ListItem>) {
+        Task::delete(self, items);
+        self.selected_task_index.select_previous();
+
+        if self.board_view {
+            self.board_sync();
+        }
+    }
+
+    /// Number of tasks in a board lane.
+    fn board_lane_len(&self, lane: usize) -> usize {
+        Task::lane_indices(self, TASK_STATUSES[lane]).len()
+    }
+
+    /// Whether the currently focused board lane has no tasks.
+    fn board_lane_is_empty(&self) -> bool {
+        self.board_lane_len(self.board_lane) == 0
+    }
+
+    /// Derive the focused lane and the per-lane selection from
+    /// `selected_task_index`. Called at the end of `Task::load_items`
+    /// while the board is active, so the board follows a task that
+    /// changed lane (status change), and when the board view is
+    /// (re)entered.
+    pub(crate) fn board_sync(&mut self) {
+        let Some(selected) = self.selected_task_index.selected() else {
+            return;
+        };
+        let Some(project) = self
+            .projects
+            .get(self.selected_project_index.selected().unwrap_or(0))
+        else {
+            return;
+        };
+        let Some(task) = project.tasks.get(selected) else {
+            return;
+        };
+        // A task with an unknown status (hand-edited JSON) belongs to no
+        // lane; keep the current focus instead of deriving a stale one.
+        let Some(lane) = TASK_STATUSES.into_iter().position(|s| s == task.status) else {
+            return;
+        };
+
+        self.board_lane = lane;
+
+        let row = Task::lane_indices(self, TASK_STATUSES[lane])
+            .iter()
+            .position(|&i| i == selected)
+            .unwrap_or(0);
+        self.board_lane_states[lane].select(Some(row));
+    }
+
+    /// Focus the previous/next board lane (wrapping) and move the task
+    /// selection to the remembered row of that lane. Switching to an
+    /// empty lane only moves the focus; task actions are guarded by
+    /// `board_lane_is_empty`.
+    fn board_switch_lane(&mut self, forward: bool) {
+        let lane_count = TASK_STATUSES.len();
+        let lane = if forward {
+            (self.board_lane + 1) % lane_count
+        } else {
+            (self.board_lane + lane_count - 1) % lane_count
+        };
+        self.board_lane = lane;
+
+        let indices = Task::lane_indices(self, TASK_STATUSES[lane]);
+        if indices.is_empty() {
+            return;
+        }
+
+        let row = self.board_lane_states[lane]
+            .selected()
+            .unwrap_or(0)
+            .min(indices.len() - 1);
+        self.board_lane_states[lane].select(Some(row));
+        self.selected_task_index.select(Some(indices[row]));
+    }
+
+    /// Move the selection one row up/down within the focused lane
+    /// (wrapping), keeping `selected_task_index` pointed at the same task.
+    fn board_move(&mut self, down: bool) {
+        let lane = self.board_lane;
+        let indices = Task::lane_indices(self, TASK_STATUSES[lane]);
+        if indices.is_empty() {
+            return;
+        }
+
+        let row = self.board_lane_states[lane]
+            .selected()
+            .unwrap_or(0)
+            .min(indices.len() - 1);
+        let row = if down {
+            if row >= indices.len() - 1 {
+                0
+            } else {
+                row + 1
+            }
+        } else if row == 0 {
+            indices.len() - 1
+        } else {
+            row - 1
+        };
+
+        self.board_lane_states[lane].select(Some(row));
+        self.selected_task_index.select(Some(indices[row]));
+    }
+
+    pub(crate) fn use_state(&mut self) -> &mut ListState {
+        match self.view_mode {
+            ViewMode::ViewProjects => &mut self.selected_project_index,
+            ViewMode::RenameProject => &mut self.selected_project_index,
+            ViewMode::AddProject => &mut self.selected_project_index,
+            ViewMode::DeleteProject => &mut self.delete_confirm_index,
+
+            ViewMode::ViewTasks => &mut self.selected_task_index,
+            ViewMode::RenameTask => &mut self.selected_task_index,
+            ViewMode::ChangeStatusTask => &mut self.selected_status_task_index,
+            ViewMode::ChangePriorityTask => &mut self.selected_priority_task_index,
+            ViewMode::AddTask => &mut self.selected_task_index,
+            ViewMode::DeleteTask => &mut self.delete_confirm_index,
+            ViewMode::ViewTaskDetails => &mut self.selected_task_index,
+            ViewMode::EditTaskNote => &mut self.selected_task_index,
+            // Timer modals can be opened from either list view; the list
+            // underneath keeps the selection state of the originating view
+            ViewMode::TimerTask | ViewMode::SetCountdown => {
+                if self.previous_view_mode == ViewMode::ViewProjects {
+                    return &mut self.selected_project_index;
+                }
+                &mut self.selected_task_index
+            }
+            ViewMode::SetTaskEstimate => &mut self.selected_task_index,
+
+            ViewMode::ViewNotes => &mut self.selected_note_index,
+            ViewMode::AddNote => &mut self.selected_note_index,
+            ViewMode::RenameNote => &mut self.selected_note_index,
+            ViewMode::DeleteNote => &mut self.delete_confirm_index,
+            ViewMode::ViewNote => &mut self.selected_note_index,
+            ViewMode::EditNote => &mut self.selected_note_index,
+
+            // Help renders the list of the view it was opened from, so it uses
+            // that view's selection state. Using the project state here used
+            // to clear `selected_project_index` when the list behind the help
+            // modal was empty (ratatui resets the state of an empty list),
+            // which then panicked in `Project::get_current` on the next frame.
+            ViewMode::ViewHelp => match self.previous_view_mode {
+                ViewMode::ViewTasks => &mut self.selected_task_index,
+                ViewMode::ViewNotes | ViewMode::ViewNote | ViewMode::EditNote => {
+                    &mut self.selected_note_index
+                }
+                _ => &mut self.selected_project_index,
+            },
+            ViewMode::InfoMigration => &mut self.selected_project_index,
+        }
+    }
+
+    fn change_view(&mut self, mode: ViewMode) {
+        self.view_mode = mode
+    }
+
+    /// Stop the active timer (if any). A stopwatch accumulates its seconds
+    /// into the bound task; a pomodoro countdown is simply discarded.
+    fn settle_timer(&mut self) {
+        if let Some(timer) = self.timer.take() {
+            if let Some(bound) = &timer.bound {
+                Task::add_time_spent(
+                    self,
+                    bound.project_index,
+                    &bound.task_title,
+                    timer.elapsed().as_secs(),
+                );
+            }
+        }
+    }
+
+    /// Return from a modal to whichever list view opened it.
+    fn back_to_previous_view(&mut self) {
+        let prev = std::mem::replace(&mut self.previous_view_mode, ViewMode::ViewProjects);
+        self.change_view(prev);
+    }
+
+    /// Countdown bookkeeping, run on every event-loop iteration: when the
+    /// pomodoro reaches zero, ring the terminal bell once and leave the
+    /// timer (and its modal, if open) in the finished state until the
+    /// user dismisses it with any key.
+    fn tick_timer(&mut self) {
+        let hit_zero = matches!(
+            self.timer.as_ref(),
+            Some(t) if t.is_finished() && !t.rung
+        );
+
+        if !hit_zero {
+            return;
+        }
+
+        print!("\x07");
+        let _ = std::io::Write::flush(&mut std::io::stdout());
+
+        if let Some(timer) = self.timer.as_mut() {
+            timer.rung = true;
+        }
+    }
+
+    fn handle_modal_nav(
+        &mut self,
+        key: KeyCode,
+        items: &[ListItem],
+        return_mode: ViewMode,
+    ) -> bool {
+        match key {
+            KeyCode::Esc => {
+                self.use_state().select(Some(0));
+                self.change_view(return_mode);
+                true
+            }
+            KeyCode::Down | KeyCode::Tab | KeyCode::Char('j') => {
+                self.next(items);
+                true
+            }
+            KeyCode::Up | KeyCode::BackTab | KeyCode::Char('k') => {
+                self.previous(items);
+                true
+            }
+            _ => false,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests;
+
+/// Performance benchmarks (opt-in, not part of the normal test run).
+///
+/// Enable the `bench` feature and run with:
+///   cargo test --release --features bench --bin basilk perf_tests -- --ignored --nocapture
+/// or: ./scripts/bench.sh
+///
+/// Typical numbers on a 2023 M-series Mac (release build):
+///   load_items 10k tasks        ~2 ms
+///   full frame @ 2k tasks       ~0.3 ms (budget is 250 ms)
+///   render_markdown 312 KB      ~3 ms
+///   Json write/read 2k tasks    <0.5 ms
+///   idle CPU (poll loop)        0.0%
+#[cfg(all(test, feature = "bench"))]
+mod perf_tests;
diff --git a/src/app/perf_tests.rs b/src/app/perf_tests.rs
new file mode 100644
index 0000000..6586fe4
--- /dev/null
+++ b/src/app/perf_tests.rs
@@ -0,0 +1,122 @@
+use super::*;
+use crate::markdown::render_markdown;
+use crate::project::Project;
+use crate::task::{Task, TASK_STATUS_UP_NEXT};
+use crate::test_utils::{make_app, make_task, setup_temp_config, ENV_LOCK};
+use ratatui::{backend::TestBackend, Terminal};
+use std::time::Instant;
+
+fn big_app(tasks_per_project: usize, projects: usize) -> App {
+    let mut projects_vec = Vec::new();
+    for p in 0..projects {
+        let mut tasks = Vec::new();
+        for t in 0..tasks_per_project {
+            tasks.push(make_task(
+                &format!("p{p} task {t}"),
+                TASK_STATUS_UP_NEXT,
+                (t % 3) as u8,
+            ));
+        }
+        projects_vec.push(Project {
+            title: format!("project {p}"),
+            tasks,
+        });
+    }
+    make_app(projects_vec)
+}
+
+#[test]
+#[ignore]
+fn probe_scaling() {
+    // --- Task::load_items (rebuilds the item list + sorts) ---
+    for (tasks, projects) in [(1000, 1), (10_000, 1)] {
+        let mut app = big_app(tasks, projects);
+        let mut items = Vec::new();
+        let t = Instant::now();
+        Task::load_items(&mut app, &mut items);
+        println!(
+            "load_items: {tasks} tasks -> {:?} ({} items)",
+            t.elapsed(),
+            items.len()
+        );
+    }
+
+    // --- Project::load_items ---
+    for projects in [100, 1000] {
+        let mut app = big_app(5, projects);
+        let mut items = Vec::new();
+        let t = Instant::now();
+        Project::load_items(&mut app, &mut items);
+        println!(
+            "project_load_items: {projects} projects -> {:?}",
+            t.elapsed()
+        );
+    }
+
+    // --- Full-frame render, list view ---
+    let mut app = big_app(2000, 1);
+    app.view_mode = ViewMode::ViewTasks;
+    let mut items = Vec::new();
+    Task::load_items(&mut app, &mut items);
+    let backend = TestBackend::new(120, 40);
+    let mut terminal = Terminal::new(backend).unwrap();
+    let input = Input::default();
+    let mut status_items = Vec::new();
+    Task::load_statuses_items(&mut status_items);
+    let mut priority_items = Vec::new();
+    Task::load_priority_items(&mut priority_items);
+
+    let frames = 120;
+    let t = Instant::now();
+    for _ in 0..frames {
+        terminal
+            .draw(|f| app.render(f, f.size(), &input, &items, &status_items, &priority_items))
+            .unwrap();
+    }
+    println!(
+        "render list @2000 tasks: {frames} frames in {:?} ({:?}/frame)",
+        t.elapsed(),
+        t.elapsed() / frames
+    );
+
+    // --- Board view render ---
+    app.board_view = true;
+    app.board_sync();
+    let t = Instant::now();
+    for _ in 0..frames {
+        terminal
+            .draw(|f| app.render(f, f.size(), &input, &items, &status_items, &priority_items))
+            .unwrap();
+    }
+    println!(
+        "render board @2000 tasks: {frames} frames in {:?} ({:?}/frame)",
+        t.elapsed(),
+        t.elapsed() / frames
+    );
+
+    // --- Markdown rendering (note preview) ---
+    let md = format!(
+        "# big doc\n\n{}",
+        "paragraph with **bold**, *italic* and `code`\n\n- item one\n- item two\n\n> quote\n\n"
+            .repeat(4000)
+    );
+    let t = Instant::now();
+    let text = render_markdown(&md);
+    println!(
+        "render_markdown: {} chars -> {:?} ({} lines)",
+        md.len(),
+        t.elapsed(),
+        text.lines.len()
+    );
+
+    // --- JSON persistence ---
+    let _guard = ENV_LOCK.lock().unwrap();
+    let _dir = setup_temp_config();
+    let app2 = big_app(2000, 1);
+    let t = Instant::now();
+    Json::write(&app2.projects).unwrap();
+    println!("Json::write @2000 tasks: {:?}", t.elapsed());
+    let t = Instant::now();
+    let _p = Json::read().unwrap();
+    println!("Json::read @2000 tasks: {:?}", t.elapsed());
+}
diff --git a/src/app/tests.rs b/src/app/tests.rs
new file mode 100644
index 0000000..5e8ec2f
--- /dev/null
+++ b/src/app/tests.rs
@@ -0,0 +1,3210 @@
+use super::*;
+use crate::test_utils::{make_app, make_task, sample_projects, setup_temp_config, ENV_LOCK};
+use crate::timer::TimerTaskBinding;
+use ratatui::crossterm::event::KeyModifiers;
+use std::time::Duration;
+
+// ---------- Shared helpers for the handler / loop / render tests ----------
+
+fn key(code: KeyCode) -> KeyEvent {
+    KeyEvent::new(code, KeyModifiers::NONE)
+}
+
+fn release_key(code: KeyCode) -> KeyEvent {
+    KeyEvent::new_with_kind(code, KeyModifiers::NONE, KeyEventKind::Release)
+}
+
+fn input_with(value: &str) -> Input {
+    Input::default().with_value(value.to_string())
+}
+
+fn confirm_items() -> Vec<ListItem<'static>> {
+    View::delete_confirm_items()
+}
+
+fn note(title: &str, body: &str) -> Note {
+    Note {
+        title: title.to_string(),
+        body: body.to_string(),
+        created_at: None,
+        updated_at: None,
+    }
+}
+
+/// A stopped (paused) stopwatch with a fixed accumulated time, so tests
+/// do not depend on wall-clock timing.
+fn paused_stopwatch(secs: u64, project_index: usize, task_title: &str) -> TimerState {
+    TimerState {
+        kind: TimerKind::Stopwatch,
+        target_secs: 0,
+        accumulated: Duration::from_secs(secs),
+        started_at: None,
+        bound: Some(TimerTaskBinding {
+            project_index,
+            task_title: task_title.to_string(),
+        }),
+        rung: false,
+    }
+}
+
+/// A stopped countdown with a fixed accumulated time.
+fn paused_countdown(target_secs: u64, accumulated_secs: u64) -> TimerState {
+    TimerState {
+        kind: TimerKind::Countdown,
+        target_secs,
+        accumulated: Duration::from_secs(accumulated_secs),
+        started_at: None,
+        bound: None,
+        rung: false,
+    }
+}
+
+#[test]
+fn next_on_empty_items_does_not_panic() {
+    let mut app = make_app(vec![]);
+    let items: Vec<ListItem> = vec![];
+
+    app.next(&items);
+    app.previous(&items);
+
+    assert_eq!(app.selected_project_index.selected(), Some(0));
+}
+
+#[test]
+fn next_wraps_around_at_the_end() {
+    let mut app = make_app(vec![]);
+    let items: Vec<ListItem> = vec![ListItem::from("a"), ListItem::from("b")];
+
+    app.next(&items);
+    assert_eq!(app.selected_project_index.selected(), Some(1));
+
+    app.next(&items);
+    assert_eq!(app.selected_project_index.selected(), Some(0));
+}
+
+#[test]
+fn previous_wraps_around_at_the_start() {
+    let mut app = make_app(vec![]);
+    let items: Vec<ListItem> = vec![ListItem::from("a"), ListItem::from("b")];
+
+    app.previous(&items);
+    assert_eq!(app.selected_project_index.selected(), Some(1));
+}
+
+#[test]
+fn use_state_maps_view_modes_to_the_right_list_state() {
+    fn assert_state(app: &mut App, mode: ViewMode, expected: fn(&App) -> *const ListState) {
+        app.view_mode = mode;
+        let actual = app.use_state() as *const ListState;
+        assert_eq!(actual, expected(app));
+    }
+
+    let mut app = make_app(vec![]);
+
+    assert_state(&mut app, ViewMode::ViewProjects, |a| {
+        &a.selected_project_index
+    });
+    assert_state(&mut app, ViewMode::RenameProject, |a| {
+        &a.selected_project_index
+    });
+    assert_state(&mut app, ViewMode::ViewTasks, |a| &a.selected_task_index);
+    assert_state(&mut app, ViewMode::RenameTask, |a| &a.selected_task_index);
+    assert_state(&mut app, ViewMode::ViewTaskDetails, |a| {
+        &a.selected_task_index
+    });
+    assert_state(&mut app, ViewMode::ChangeStatusTask, |a| {
+        &a.selected_status_task_index
+    });
+    assert_state(&mut app, ViewMode::ChangePriorityTask, |a| {
+        &a.selected_priority_task_index
+    });
+    assert_state(&mut app, ViewMode::DeleteProject, |a| {
+        &a.delete_confirm_index
+    });
+    assert_state(&mut app, ViewMode::DeleteTask, |a| &a.delete_confirm_index);
+    assert_state(&mut app, ViewMode::ViewNotes, |a| &a.selected_note_index);
+    assert_state(&mut app, ViewMode::AddNote, |a| &a.selected_note_index);
+    assert_state(&mut app, ViewMode::RenameNote, |a| &a.selected_note_index);
+    assert_state(&mut app, ViewMode::ViewNote, |a| &a.selected_note_index);
+    assert_state(&mut app, ViewMode::EditNote, |a| &a.selected_note_index);
+    assert_state(&mut app, ViewMode::DeleteNote, |a| &a.delete_confirm_index);
+}
+
+mod board {
+    use super::*;
+    use crate::task::{
+        TASK_PRIORITY_NONE, TASK_STATUS_DONE, TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT,
+    };
+    use crate::test_utils::{make_task, setup_temp_config, ENV_LOCK};
+
+    fn board_app() -> App {
+        make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("ongoing", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+                make_task("upnext", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("done", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            ],
+        }])
+    }
+
+    #[test]
+    fn board_sync_focuses_the_lane_of_the_selected_task() {
+        let mut app = board_app();
+        app.selected_task_index.select(Some(0)); // "ongoing"
+
+        app.board_sync();
+
+        // TASK_STATUSES order: UpNext = 0, OnGoing = 1, Done = 2
+        assert_eq!(app.board_lane, 1);
+        assert_eq!(app.board_lane_states[1].selected(), Some(0));
+    }
+
+    #[test]
+    fn board_sync_follows_a_task_that_changed_lane() {
+        let mut app = board_app();
+        app.board_view = true;
+        app.selected_task_index.select(Some(0));
+        app.projects[0].tasks[0].status = TASK_STATUS_DONE.to_string();
+
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        // The selection follows the task into the Done lane instead of
+        // jumping to the first still-visible list item
+        assert_eq!(Task::get_current(&app).title, "ongoing");
+        assert_eq!(app.board_lane, 2);
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+        assert_eq!(app.board_lane_states[2].selected(), Some(0));
+    }
+
+    #[test]
+    fn lane_indices_groups_by_status_and_ignores_hide_done() {
+        let app = board_app();
+        assert!(app.hide_done_tasks);
+
+        assert_eq!(Task::lane_indices(&app, TASK_STATUS_UP_NEXT), vec![1]);
+        assert_eq!(Task::lane_indices(&app, TASK_STATUS_ON_GOING), vec![0]);
+        assert_eq!(Task::lane_indices(&app, TASK_STATUS_DONE), vec![2]);
+    }
+
+    #[test]
+    fn board_switch_lane_wraps_and_moves_the_task_selection() {
+        let mut app = board_app();
+        app.selected_task_index.select(Some(0));
+        app.board_sync(); // lane 1 (OnGoing)
+
+        app.board_switch_lane(true); // lane 2 (Done)
+        assert_eq!(app.board_lane, 2);
+        assert_eq!(app.selected_task_index.selected(), Some(2));
+
+        app.board_switch_lane(true); // wraps to lane 0 (UpNext)
+        assert_eq!(app.board_lane, 0);
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+
+        app.board_switch_lane(false); // back to lane 2 (Done)
+        assert_eq!(app.board_lane, 2);
+        assert_eq!(app.selected_task_index.selected(), Some(2));
+    }
+
+    #[test]
+    fn board_switch_lane_into_an_empty_lane_keeps_the_task_selection() {
+        let mut app = board_app();
+        app.projects[0]
+            .tasks
+            .retain(|t| t.status != TASK_STATUS_ON_GOING);
+        app.selected_task_index.select(Some(0)); // "upnext"
+        app.board_sync();
+        assert_eq!(app.board_lane, 0);
+
+        app.board_switch_lane(true); // OnGoing lane, now empty
+
+        assert_eq!(app.board_lane, 1);
+        assert!(app.board_lane_is_empty());
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn board_move_wraps_within_the_lane() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("b", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        app.selected_task_index.select(Some(0));
+        app.board_sync();
+
+        app.board_move(true);
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+
+        app.board_move(true); // wraps to the top
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+
+        app.board_move(false); // wraps to the bottom
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+    }
+
+    /// Regression test: deleting a task in board mode used to leave the
+    /// board focus on the deleted task's successor while
+    /// `selected_task_index` (the action target) moved to the
+    /// predecessor — the two must agree after the delete sequence.
+    #[test]
+    fn delete_in_board_mode_keeps_focus_and_action_target_consistent() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("b", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("c", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        app.board_view = true;
+
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items); // sorted: [c, a, b]
+        app.selected_task_index.select(Some(1)); // "a"
+        app.board_sync();
+        assert_eq!(Task::get_current(&app).title, "a");
+
+        // Exercise the same code path as the DeleteTask handler
+        app.delete_current_task(&mut items);
+
+        assert_eq!(Task::get_current(&app).title, "c");
+        let lane = app.board_lane;
+        let row = app.board_lane_states[lane].selected().unwrap();
+        let lane_indices = Task::lane_indices(&app, TASK_STATUSES[lane]);
+        assert_eq!(
+            lane_indices.get(row).copied(),
+            app.selected_task_index.selected(),
+            "board focus and action target diverged"
+        );
+    }
+}
+
+// ------------------------------------------------------------------------
+// Key handlers
+// ------------------------------------------------------------------------
+mod handlers {
+    use super::*;
+    use crate::note::Note;
+    use crate::project::Project;
+    use crate::task::{
+        TASK_PRIORITY_NONE, TASK_STATUS_DONE, TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT,
+    };
+    use tui_textarea::TextArea;
+
+    fn tasks_app() -> App {
+        make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("b", TASK_STATUS_UP_NEXT, 1),
+            ],
+        }])
+    }
+
+    // ---- ViewProjects ----
+
+    #[test]
+    fn projects_h_opens_help() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_projects(key(KeyCode::Char('h')), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::None);
+        assert_eq!(app.view_mode, ViewMode::ViewHelp);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn projects_enter_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_projects(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn projects_enter_opens_tasks_and_loads_them() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        let action = app.handle_view_projects(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::None);
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+        assert_eq!(items.len(), 2);
+    }
+
+    #[test]
+    fn projects_enter_in_board_mode_resyncs_the_board() {
+        let mut app = tasks_app();
+        app.board_view = true;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_view_projects(key(KeyCode::Right), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.board_lane, 0); // UpNext lane of the selected task
+        assert_eq!(app.board_lane_states[0].selected(), Some(0));
+    }
+
+    #[test]
+    fn projects_l_opens_tasks_too() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_view_projects(key(KeyCode::Char('l')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn projects_r_starts_renaming_the_selected_project() {
+        let mut app = make_app(sample_projects());
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_view_projects(key(KeyCode::Char('r')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::RenameProject);
+        assert_eq!(input.value(), "alpha");
+    }
+
+    #[test]
+    fn projects_r_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_projects(key(KeyCode::Char('r')), &mut input, &mut items),
+            KeyAction::Skip
+        );
+    }
+
+    #[test]
+    fn projects_n_starts_adding_a_project() {
+        let mut app = make_app(vec![]);
+        let mut input = input_with("stale");
+        let mut items = vec![];
+
+        app.handle_view_projects(key(KeyCode::Char('n')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::AddProject);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn projects_d_opens_the_delete_modal() {
+        let mut app = make_app(sample_projects());
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_view_projects(key(KeyCode::Char('d')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::DeleteProject);
+    }
+
+    #[test]
+    fn projects_d_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_projects(key(KeyCode::Char('d')), &mut input, &mut items),
+            KeyAction::Skip
+        );
+    }
+
+    #[test]
+    fn projects_navigation_keys_move_the_selection() {
+        let mut app = make_app(sample_projects());
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_view_projects(key(KeyCode::Down), &mut input, &mut items);
+        assert_eq!(app.selected_project_index.selected(), Some(1));
+
+        app.handle_view_projects(key(KeyCode::Char('j')), &mut input, &mut items);
+        assert_eq!(app.selected_project_index.selected(), Some(0)); // wraps
+
+        app.handle_view_projects(key(KeyCode::Up), &mut input, &mut items);
+        assert_eq!(app.selected_project_index.selected(), Some(1)); // wraps
+
+        app.handle_view_projects(key(KeyCode::BackTab), &mut input, &mut items);
+        app.handle_view_projects(key(KeyCode::Char('k')), &mut input, &mut items);
+        assert_eq!(app.selected_project_index.selected(), Some(1));
+    }
+
+    #[test]
+    fn projects_c_starts_a_countdown_when_no_timer_runs() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_view_projects(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::SetCountdown);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewProjects);
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn projects_c_opens_the_timer_when_one_runs() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_stopwatch(10, 0, "t"));
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_view_projects(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::TimerTask);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn projects_m_opens_the_notes_view() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "body")];
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_view_projects(key(KeyCode::Char('m')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(items.len(), 1);
+    }
+
+    #[test]
+    fn projects_q_quits() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_projects(key(KeyCode::Char('q')), &mut input, &mut items),
+            KeyAction::Quit
+        );
+    }
+
+    #[test]
+    fn projects_unknown_keys_do_nothing() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_projects(key(KeyCode::Char('z')), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::None);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    // ---- RenameProject / AddProject / DeleteProject ----
+
+    #[test]
+    fn rename_project_enter_renames_and_returns() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        let mut input = input_with("renamed");
+        let mut items = vec![];
+
+        app.handle_rename_project(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.projects[0].title, "renamed");
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn rename_project_esc_cancels() {
+        let mut app = make_app(sample_projects());
+        let mut input = input_with("discard me");
+        let mut items = vec![];
+
+        app.handle_rename_project(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(input.value(), "");
+        assert_eq!(app.projects[0].title, "alpha");
+    }
+
+    #[test]
+    fn rename_project_other_keys_edit_the_input() {
+        let mut app = make_app(sample_projects());
+        app.view_mode = ViewMode::RenameProject;
+        let mut input = input_with("ab");
+        let mut items = vec![];
+
+        app.handle_rename_project(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "abc");
+        assert_eq!(app.view_mode, ViewMode::RenameProject);
+    }
+
+    #[test]
+    fn add_project_esc_cancels() {
+        let mut app = make_app(vec![]);
+        let mut input = input_with("todo");
+        let mut items = vec![];
+
+        app.handle_add_project(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert!(app.projects.is_empty());
+    }
+
+    #[test]
+    fn add_project_empty_enter_just_returns() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_add_project(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert!(app.projects.is_empty());
+    }
+
+    #[test]
+    fn add_project_enter_creates_and_selects_the_new_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut input = input_with("todo");
+        let mut items = vec![];
+
+        app.handle_add_project(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.projects.len(), 1);
+        assert_eq!(app.projects[0].title, "todo");
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn add_project_other_keys_edit_the_input() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::AddProject;
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_add_project(key(KeyCode::Char('x')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "x");
+        assert_eq!(app.view_mode, ViewMode::AddProject);
+    }
+
+    #[test]
+    fn delete_project_esc_returns_and_resets_the_selection() {
+        let mut app = make_app(sample_projects());
+        let mut items = vec![];
+
+        let action = app.handle_delete_project(key(KeyCode::Esc), &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.delete_confirm_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn delete_project_navigation_moves_the_confirm_selection() {
+        let mut app = make_app(sample_projects());
+        app.view_mode = ViewMode::DeleteProject;
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Down), &mut items);
+        assert_eq!(app.delete_confirm_index.selected(), Some(1));
+
+        app.handle_delete_project(key(KeyCode::Char('k')), &mut items);
+        assert_eq!(app.delete_confirm_index.selected(), Some(0));
+
+        app.handle_delete_project(key(KeyCode::Char('j')), &mut items);
+        assert_eq!(app.delete_confirm_index.selected(), Some(1));
+    }
+
+    #[test]
+    fn delete_project_confirm_deletes_and_returns() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.projects.len(), 1);
+        assert_eq!(app.projects[0].title, "beta");
+        assert_eq!(app.delete_confirm_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn delete_project_cancel_keeps_the_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        app.delete_confirm_index.select(Some(1));
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.projects.len(), 2);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn delete_project_drops_a_timer_bound_to_it() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects()); // alpha=0, beta=1
+        app.selected_project_index.select(Some(1));
+        app.timer = Some(paused_stopwatch(10, 1, "t"));
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn delete_project_reindexes_a_timer_bound_to_a_later_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![
+            Project {
+                title: "a".to_string(),
+                tasks: vec![],
+            },
+            Project {
+                title: "b".to_string(),
+                tasks: vec![],
+            },
+            Project {
+                title: "c".to_string(),
+                tasks: vec![],
+            },
+        ]);
+        app.selected_project_index.select(Some(1)); // delete "b"
+        app.timer = Some(paused_stopwatch(10, 2, "t")); // bound to "c"
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        let bound = app.timer.as_ref().unwrap().bound.as_ref().unwrap();
+        assert_eq!(bound.project_index, 1);
+    }
+
+    // ---- ViewTasks ----
+
+    #[test]
+    fn tasks_h_opens_help() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('h')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewHelp);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn tasks_esc_returns_to_projects() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(items.len(), 1); // project items reloaded
+    }
+
+    #[test]
+    fn tasks_left_returns_in_list_mode_but_switches_lane_in_board_mode() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Left), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+
+        // Board mode: Left moves the lane focus instead of going back
+        let mut app = tasks_app();
+        app.board_view = true;
+        app.view_mode = ViewMode::ViewTasks;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_task_index.select(Some(0));
+        app.board_sync();
+        assert_eq!(app.board_lane, 0);
+
+        app.handle_view_tasks(key(KeyCode::Left), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.board_lane, 2); // wrapped backwards to Done
+    }
+
+    #[test]
+    fn tasks_right_switches_lane_in_board_mode() {
+        let mut app = tasks_app();
+        app.board_view = true;
+        app.view_mode = ViewMode::ViewTasks;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_task_index.select(Some(0));
+        app.board_sync();
+
+        app.handle_view_tasks(key(KeyCode::Right), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.board_lane, 1);
+    }
+
+    #[test]
+    fn tasks_b_toggles_the_board_and_rebuilds_the_items() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("done", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        assert_eq!(items.len(), 1); // done tasks are hidden in the list
+
+        app.handle_view_tasks(key(KeyCode::Char('b')), &mut input, &mut items);
+        assert!(app.board_view);
+        assert_eq!(items.len(), 2); // the board always shows the Done lane
+
+        app.handle_view_tasks(key(KeyCode::Char('b')), &mut input, &mut items);
+        assert!(!app.board_view);
+    }
+
+    #[test]
+    fn tasks_enter_opens_the_status_modal() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        assert_eq!(Task::get_current(&app).status, TASK_STATUS_UP_NEXT);
+
+        app.handle_view_tasks(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ChangeStatusTask);
+        assert_eq!(app.selected_status_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn tasks_enter_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_tasks(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+    }
+
+    #[test]
+    fn tasks_actions_on_an_empty_board_lane_skip() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.board_view = true;
+        app.view_mode = ViewMode::ViewTasks;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.board_lane = 2; // the Done lane is empty
+
+        for code in [
+            KeyCode::Enter,
+            KeyCode::Char('p'),
+            KeyCode::Char('r'),
+            KeyCode::Char('d'),
+            KeyCode::Char('v'),
+            KeyCode::Char('e'),
+        ] {
+            assert_eq!(
+                app.handle_view_tasks(key(code), &mut input, &mut items),
+                KeyAction::Skip
+            );
+        }
+
+        // 's' is also a no-op without a current task, but stays in the view
+        app.handle_view_tasks(key(KeyCode::Char('s')), &mut input, &mut items);
+        assert!(app.timer.is_none());
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn tasks_p_opens_the_priority_modal() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('p')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ChangePriorityTask);
+        let task = Task::get_current(&app);
+        let index = TASK_PRIORITIES
+            .into_iter()
+            .position(|p| p == task.priority)
+            .unwrap();
+        assert_eq!(app.selected_priority_task_index.selected(), Some(index));
+    }
+
+    #[test]
+    fn tasks_r_prefills_the_rename_input() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let title = Task::get_current(&app).title.clone();
+
+        app.handle_view_tasks(key(KeyCode::Char('r')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::RenameTask);
+        assert_eq!(input.value(), title);
+    }
+
+    #[test]
+    fn tasks_n_starts_adding_a_task() {
+        let mut app = tasks_app();
+        let mut input = input_with("stale");
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('n')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::AddTask);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn tasks_d_opens_the_delete_modal() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('d')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::DeleteTask);
+    }
+
+    #[test]
+    fn tasks_v_opens_the_details_view() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('v')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+    }
+
+    #[test]
+    fn tasks_e_prefills_the_note_editor() {
+        let mut app = tasks_app();
+        app.projects[0].tasks[0].note = "my note".to_string();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('e')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::EditTaskNote);
+        assert_eq!(input.value(), "my note");
+    }
+
+    #[test]
+    fn tasks_board_jk_moves_within_the_lane() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("x", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("y", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        app.board_view = true;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_task_index.select(Some(0));
+        app.board_sync();
+
+        app.handle_view_tasks(key(KeyCode::Char('j')), &mut input, &mut items);
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+
+        app.handle_view_tasks(key(KeyCode::Char('k')), &mut input, &mut items);
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn tasks_jk_navigate_the_list_in_list_mode() {
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::ViewTasks;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_task_index.select(Some(0));
+
+        app.handle_view_tasks(key(KeyCode::Char('j')), &mut input, &mut items);
+        assert_eq!(app.selected_task_index.selected(), Some(1));
+
+        app.handle_view_tasks(key(KeyCode::Char('k')), &mut input, &mut items);
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn tasks_t_toggles_done_visibility() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("done", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        assert_eq!(items.len(), 1);
+
+        app.handle_view_tasks(key(KeyCode::Char('t')), &mut input, &mut items);
+
+        assert!(!app.hide_done_tasks);
+        assert_eq!(items.len(), 2);
+    }
+
+    #[test]
+    fn tasks_t_is_a_no_op_in_board_mode() {
+        let mut app = tasks_app();
+        app.board_view = true;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('t')), &mut input, &mut items);
+
+        assert!(app.hide_done_tasks);
+    }
+
+    #[test]
+    fn tasks_s_starts_a_stopwatch_for_the_selected_task() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let title = Task::get_current(&app).title.clone();
+
+        app.handle_view_tasks(key(KeyCode::Char('s')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::TimerTask);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewTasks);
+        let timer = app.timer.as_ref().unwrap();
+        assert_eq!(timer.kind, TimerKind::Stopwatch);
+        assert_eq!(timer.bound.as_ref().unwrap().project_index, 0);
+        assert_eq!(timer.bound.as_ref().unwrap().task_title, title);
+    }
+
+    #[test]
+    fn tasks_s_opens_the_timer_when_one_runs() {
+        let mut app = tasks_app();
+        app.timer = Some(paused_stopwatch(10, 0, "a"));
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('s')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::TimerTask);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn tasks_c_opens_the_countdown_or_timer() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        app.handle_view_tasks(key(KeyCode::Char('c')), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::SetCountdown);
+
+        app.timer = Some(paused_stopwatch(10, 0, "a"));
+        app.handle_view_tasks(key(KeyCode::Char('c')), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::TimerTask);
+    }
+
+    #[test]
+    fn tasks_q_quits() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        assert_eq!(
+            app.handle_view_tasks(key(KeyCode::Char('q')), &mut input, &mut items),
+            KeyAction::Quit
+        );
+    }
+
+    #[test]
+    fn tasks_unknown_keys_do_nothing() {
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::ViewTasks;
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+
+        let action = app.handle_view_tasks(key(KeyCode::Char('z')), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::None);
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    // ---- RenameTask / status / priority / AddTask / DeleteTask ----
+
+    #[test]
+    fn rename_task_enter_renames_and_retargets_the_timer() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let old_title = Task::get_current(&app).title.clone();
+        app.timer = Some(paused_stopwatch(10, 0, &old_title));
+        let mut input = input_with("renamed");
+
+        app.handle_rename_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(Task::get_current(&app).title, "renamed");
+        assert_eq!(
+            app.timer
+                .as_ref()
+                .unwrap()
+                .bound
+                .as_ref()
+                .unwrap()
+                .task_title,
+            "renamed"
+        );
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn rename_task_esc_cancels() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("discard");
+
+        app.handle_rename_task(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn rename_task_other_keys_edit_the_input() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("ab");
+
+        app.handle_rename_task(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "abc");
+    }
+
+    #[test]
+    fn change_status_enter_applies_the_selected_status() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_status_task_index.select(Some(1)); // OnGoing
+
+        app.handle_change_status_task(key(KeyCode::Enter), &mut items, &[]);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(Task::get_current(&app).status, TASK_STATUS_ON_GOING);
+        assert_eq!(app.selected_status_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn change_status_navigation_moves_the_selection() {
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::ChangeStatusTask;
+        let mut items = vec![];
+        let mut status_items = vec![];
+        Task::load_statuses_items(&mut status_items);
+
+        let action = app.handle_change_status_task(key(KeyCode::Down), &mut items, &status_items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.selected_status_task_index.selected(), Some(1));
+    }
+
+    #[test]
+    fn change_priority_enter_applies_the_selected_priority() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_priority_task_index.select(Some(2)); // priority 3
+
+        app.handle_change_priority_task(key(KeyCode::Enter), &mut items, &[]);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(Task::get_current(&app).priority, 3);
+        assert_eq!(app.selected_priority_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn change_priority_navigation_moves_the_selection() {
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::ChangePriorityTask;
+        let mut items = vec![];
+        let mut priority_items = vec![];
+        Task::load_priority_items(&mut priority_items);
+
+        let action =
+            app.handle_change_priority_task(key(KeyCode::Char('j')), &mut items, &priority_items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.selected_priority_task_index.selected(), Some(1));
+    }
+
+    #[test]
+    fn add_task_enter_creates_the_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let count = app.projects[0].tasks.len();
+        let mut input = input_with("new task");
+
+        app.handle_add_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.projects[0].tasks.len(), count + 1);
+        assert_eq!(items.len(), count + 1);
+    }
+
+    #[test]
+    fn add_task_enter_with_a_duplicate_title_stays_in_the_view() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::AddTask;
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let count = app.projects[0].tasks.len();
+        let mut input = input_with("a"); // already exists
+
+        app.handle_add_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::AddTask);
+        assert_eq!(app.projects[0].tasks.len(), count);
+        assert_eq!(input.value(), "a"); // input kept for another try
+    }
+
+    #[test]
+    fn add_task_enter_with_an_empty_title_stays_in_the_view() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::AddTask;
+        let mut items = vec![];
+        let count = app.projects[0].tasks.len();
+        let mut input = Input::default();
+
+        app.handle_add_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::AddTask);
+        assert_eq!(app.projects[0].tasks.len(), count);
+    }
+
+    #[test]
+    fn rename_task_enter_with_a_duplicate_title_stays_in_the_view() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app(); // selected task is "a", "b" exists
+        app.view_mode = ViewMode::RenameTask;
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("b");
+
+        app.handle_rename_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::RenameTask);
+        assert_eq!(Task::get_current(&app).title, "a");
+        assert_eq!(input.value(), "b"); // input kept for another try
+    }
+
+    #[test]
+    fn add_task_esc_cancels() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let count = app.projects[0].tasks.len();
+        let mut input = input_with("new task");
+
+        app.handle_add_task(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.projects[0].tasks.len(), count);
+    }
+
+    #[test]
+    fn add_task_other_keys_edit_the_input() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        let mut input = Input::default();
+
+        app.handle_add_task(key(KeyCode::Char('x')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "x");
+    }
+
+    #[test]
+    fn delete_task_confirm_removes_the_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let count = app.projects[0].tasks.len();
+
+        app.handle_delete_task(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(app.projects[0].tasks.len(), count - 1);
+    }
+
+    #[test]
+    fn delete_task_cancel_keeps_the_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let count = app.projects[0].tasks.len();
+        app.delete_confirm_index.select(Some(1));
+
+        app.handle_delete_task(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.projects[0].tasks.len(), count);
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn delete_task_drops_a_bound_timer() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let title = Task::get_current(&app).title.clone();
+        app.timer = Some(paused_stopwatch(10, 0, &title));
+
+        app.handle_delete_task(key(KeyCode::Enter), &mut items);
+
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn delete_task_esc_returns() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+
+        let action = app.handle_delete_task(key(KeyCode::Esc), &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    // ---- ViewTaskDetails / EditTaskNote / SetTaskEstimate ----
+
+    #[test]
+    fn task_details_e_edits_the_note() {
+        let mut app = tasks_app();
+        app.projects[0].tasks[0].note = "my note".to_string();
+        let mut input = Input::default();
+
+        app.handle_view_task_details(key(KeyCode::Char('e')), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::EditTaskNote);
+        assert_eq!(input.value(), "my note");
+    }
+
+    #[test]
+    fn task_details_g_edits_the_estimate() {
+        let mut app = tasks_app();
+        app.projects[0].tasks[0].estimated_hours = 7;
+        let mut input = Input::default();
+
+        app.handle_view_task_details(key(KeyCode::Char('g')), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::SetTaskEstimate);
+        assert_eq!(input.value(), "7");
+    }
+
+    #[test]
+    fn task_details_g_without_an_estimate_starts_empty() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+
+        app.handle_view_task_details(key(KeyCode::Char('g')), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::SetTaskEstimate);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn task_details_any_other_key_closes() {
+        let mut app = tasks_app();
+        let mut input = Input::default();
+
+        app.handle_view_task_details(key(KeyCode::Esc), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn edit_task_note_enter_saves() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("the note");
+
+        app.handle_edit_task_note(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+        assert_eq!(Task::get_current(&app).note, "the note");
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn edit_task_note_esc_cancels() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("discard");
+
+        app.handle_edit_task_note(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+        assert_eq!(input.value(), "");
+        assert_eq!(Task::get_current(&app).note, "");
+    }
+
+    #[test]
+    fn edit_task_note_other_keys_edit_the_input() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        let mut input = input_with("ab");
+
+        app.handle_edit_task_note(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "abc");
+    }
+
+    #[test]
+    fn set_estimate_enter_applies_the_value() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("  5  ");
+
+        app.handle_set_task_estimate(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+        assert_eq!(Task::get_current(&app).estimated_hours, 5);
+    }
+
+    #[test]
+    fn set_estimate_empty_enter_returns_without_changes() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = Input::default();
+
+        app.handle_set_task_estimate(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+        assert_eq!(Task::get_current(&app).estimated_hours, 0);
+    }
+
+    #[test]
+    fn set_estimate_invalid_enter_stays_in_the_modal() {
+        let mut app = tasks_app();
+        app.view_mode = ViewMode::SetTaskEstimate;
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("abc");
+
+        app.handle_set_task_estimate(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::SetTaskEstimate);
+        assert_eq!(Task::get_current(&app).estimated_hours, 0);
+    }
+
+    #[test]
+    fn set_estimate_esc_returns() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("5");
+
+        app.handle_set_task_estimate(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewTaskDetails);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn set_estimate_filters_non_digit_keys() {
+        let mut app = tasks_app();
+        let mut items = vec![];
+        let mut input = Input::default();
+
+        app.handle_set_task_estimate(key(KeyCode::Char('a')), &mut input, &mut items);
+        assert_eq!(input.value(), "");
+
+        app.handle_set_task_estimate(key(KeyCode::Char('7')), &mut input, &mut items);
+        assert_eq!(input.value(), "7");
+
+        app.handle_set_task_estimate(key(KeyCode::Backspace), &mut input, &mut items);
+        assert_eq!(input.value(), "");
+    }
+
+    // ---- TimerTask / SetCountdown ----
+
+    #[test]
+    fn timer_task_space_pauses_and_resumes() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(TimerState::new_stopwatch(0, "t".to_string()));
+
+        app.handle_timer_task(key(KeyCode::Char(' ')));
+        assert!(!app.timer.as_ref().unwrap().is_running());
+
+        app.handle_timer_task(key(KeyCode::Char(' ')));
+        assert!(app.timer.as_ref().unwrap().is_running());
+    }
+
+    #[test]
+    fn timer_task_enter_settles_and_returns() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let title = Task::get_current(&app).title.clone();
+        app.timer = Some(paused_stopwatch(90, 0, &title));
+        app.previous_view_mode = ViewMode::ViewTasks;
+
+        app.handle_timer_task(key(KeyCode::Enter));
+
+        assert!(app.timer.is_none());
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+        assert_eq!(Task::get_current(&app).time_spent_secs, 90);
+    }
+
+    #[test]
+    fn timer_task_esc_returns_without_settling() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_stopwatch(90, 0, "t"));
+        app.previous_view_mode = ViewMode::ViewProjects;
+
+        app.handle_timer_task(key(KeyCode::Esc));
+
+        assert!(app.timer.is_some());
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn timer_task_finished_countdown_dismisses_on_any_key() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(60, 60)); // finished
+        app.previous_view_mode = ViewMode::ViewTasks;
+
+        let action = app.handle_timer_task(key(KeyCode::Char('x')));
+
+        assert_eq!(action, KeyAction::Skip);
+        assert!(app.timer.is_none());
+        assert_eq!(app.view_mode, ViewMode::ViewTasks);
+    }
+
+    #[test]
+    fn set_countdown_enter_starts_a_countdown() {
+        let mut app = make_app(vec![]);
+        app.previous_view_mode = ViewMode::ViewProjects;
+        let mut input = input_with("2.5");
+
+        app.handle_set_countdown(key(KeyCode::Enter), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::TimerTask);
+        let timer = app.timer.as_ref().unwrap();
+        assert_eq!(timer.kind, TimerKind::Countdown);
+        assert_eq!(timer.target_secs, 150);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn set_countdown_empty_enter_returns_to_the_previous_view() {
+        let mut app = make_app(vec![]);
+        app.previous_view_mode = ViewMode::ViewProjects;
+        let mut input = Input::default();
+
+        app.handle_set_countdown(key(KeyCode::Enter), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn set_countdown_invalid_enter_stays_in_the_modal() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::SetCountdown;
+        let mut input = input_with("abc");
+
+        app.handle_set_countdown(key(KeyCode::Enter), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::SetCountdown);
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn set_countdown_esc_returns() {
+        let mut app = make_app(vec![]);
+        app.previous_view_mode = ViewMode::ViewNotes;
+        let mut input = input_with("25");
+
+        app.handle_set_countdown(key(KeyCode::Esc), &mut input);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn set_countdown_filters_input() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+
+        app.handle_set_countdown(key(KeyCode::Char('a')), &mut input);
+        assert_eq!(input.value(), "");
+
+        app.handle_set_countdown(key(KeyCode::Char('.')), &mut input);
+        assert_eq!(input.value(), ".");
+
+        app.handle_set_countdown(key(KeyCode::Char('9')), &mut input);
+        assert_eq!(input.value(), ".9");
+    }
+
+    // ---- ViewNotes / AddNote / RenameNote / DeleteNote ----
+
+    #[test]
+    fn notes_h_opens_help() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_view_notes(key(KeyCode::Char('h')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewHelp);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewNotes);
+    }
+
+    #[test]
+    fn notes_esc_returns_to_projects() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_view_notes(key(KeyCode::Esc), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+
+        app.handle_view_notes(key(KeyCode::Left), &mut input, &mut items);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn notes_enter_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_notes(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+    }
+
+    #[test]
+    fn notes_enter_opens_the_preview_and_resets_the_scroll() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "body")];
+        let mut input = Input::default();
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+        app.note_scroll = 5;
+
+        app.handle_view_notes(key(KeyCode::Char('v')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNote);
+        assert_eq!(app.note_scroll, 0);
+    }
+
+    #[test]
+    fn notes_n_starts_adding_a_note() {
+        let mut app = make_app(vec![]);
+        let mut input = input_with("stale");
+        let mut items = vec![];
+
+        app.handle_view_notes(key(KeyCode::Char('n')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::AddNote);
+        assert_eq!(input.value(), "");
+    }
+
+    #[test]
+    fn notes_r_prefills_the_rename_input() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("my note", "")];
+        let mut input = Input::default();
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+
+        app.handle_view_notes(key(KeyCode::Char('r')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::RenameNote);
+        assert_eq!(input.value(), "my note");
+    }
+
+    #[test]
+    fn notes_r_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_notes(key(KeyCode::Char('r')), &mut input, &mut items),
+            KeyAction::Skip
+        );
+    }
+
+    #[test]
+    fn notes_d_opens_the_delete_modal() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut input = Input::default();
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+
+        app.handle_view_notes(key(KeyCode::Char('d')), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::DeleteNote);
+    }
+
+    #[test]
+    fn notes_d_on_an_empty_list_skips() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_notes(key(KeyCode::Char('d')), &mut input, &mut items),
+            KeyAction::Skip
+        );
+    }
+
+    #[test]
+    fn notes_unknown_keys_do_nothing() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        let action = app.handle_view_notes(key(KeyCode::Char('z')), &mut input, &mut items);
+
+        assert_eq!(action, KeyAction::None);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn notes_navigation_moves_the_selection() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::ViewNotes;
+        app.notes = vec![note("n1", ""), note("n2", "")];
+        let mut input = Input::default();
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+
+        app.handle_view_notes(key(KeyCode::Down), &mut input, &mut items);
+        assert_eq!(app.selected_note_index.selected(), Some(1));
+
+        app.handle_view_notes(key(KeyCode::Char('k')), &mut input, &mut items);
+        assert_eq!(app.selected_note_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn notes_q_quits() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_notes(key(KeyCode::Char('q')), &mut input, &mut items),
+            KeyAction::Quit
+        );
+    }
+
+    #[test]
+    fn add_note_enter_creates_and_selects_the_new_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut input = input_with("shopping");
+        let mut items = vec![];
+
+        app.handle_add_note(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.notes.len(), 1);
+        assert_eq!(app.notes[0].title, "shopping");
+        assert_eq!(app.selected_note_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn add_note_empty_enter_just_returns() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_add_note(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert!(app.notes.is_empty());
+    }
+
+    #[test]
+    fn add_note_esc_cancels() {
+        let mut app = make_app(vec![]);
+        let mut input = input_with("shopping");
+        let mut items = vec![];
+
+        app.handle_add_note(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert!(app.notes.is_empty());
+    }
+
+    #[test]
+    fn add_note_other_keys_edit_the_input() {
+        let mut app = make_app(vec![]);
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_add_note(key(KeyCode::Char('x')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "x");
+    }
+
+    #[test]
+    fn rename_note_enter_renames_and_returns() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("old", "")];
+        let mut input = input_with("new");
+        let mut items = vec![];
+
+        app.handle_rename_note(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.notes[0].title, "new");
+    }
+
+    #[test]
+    fn rename_note_enter_with_an_empty_title_keeps_the_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("old", "")];
+        let mut input = Input::default();
+        let mut items = vec![];
+
+        app.handle_rename_note(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.notes[0].title, "old");
+    }
+
+    #[test]
+    fn rename_note_esc_cancels() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("old", "")];
+        let mut input = input_with("discard");
+        let mut items = vec![];
+
+        app.handle_rename_note(key(KeyCode::Esc), &mut input, &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.notes[0].title, "old");
+    }
+
+    #[test]
+    fn rename_note_other_keys_edit_the_input() {
+        let mut app = make_app(vec![]);
+        let mut input = input_with("ab");
+        let mut items = vec![];
+
+        app.handle_rename_note(key(KeyCode::Char('c')), &mut input, &mut items);
+
+        assert_eq!(input.value(), "abc");
+    }
+
+    #[test]
+    fn delete_note_confirm_removes_the_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n1", ""), note("n2", "")];
+        app.selected_note_index.select(Some(1));
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+
+        app.handle_delete_note(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.notes.len(), 1);
+        assert_eq!(app.notes[0].title, "n1");
+    }
+
+    #[test]
+    fn delete_note_cancel_keeps_the_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n1", ""), note("n2", "")];
+        app.delete_confirm_index.select(Some(1));
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+
+        app.handle_delete_note(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.notes.len(), 2);
+    }
+
+    #[test]
+    fn delete_note_esc_returns() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n1", "")];
+        let mut items = vec![];
+
+        let action = app.handle_delete_note(key(KeyCode::Esc), &mut items);
+
+        assert_eq!(action, KeyAction::Skip);
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+    }
+
+    // ---- ViewNote / EditNote ----
+
+    #[test]
+    fn view_note_scrolling_keys() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "body")];
+        let mut items = vec![];
+
+        app.handle_view_note(key(KeyCode::Down), &mut items);
+        assert_eq!(app.note_scroll, 1);
+        app.handle_view_note(key(KeyCode::Char('j')), &mut items);
+        assert_eq!(app.note_scroll, 2);
+        app.handle_view_note(key(KeyCode::Up), &mut items);
+        assert_eq!(app.note_scroll, 1);
+        app.handle_view_note(key(KeyCode::Char('k')), &mut items);
+        assert_eq!(app.note_scroll, 0);
+        app.handle_view_note(key(KeyCode::Up), &mut items); // clamped at 0
+        assert_eq!(app.note_scroll, 0);
+        app.handle_view_note(key(KeyCode::PageDown), &mut items);
+        assert_eq!(app.note_scroll, 10);
+        app.handle_view_note(key(KeyCode::PageUp), &mut items);
+        assert_eq!(app.note_scroll, 0);
+        app.handle_view_note(key(KeyCode::End), &mut items);
+        assert_eq!(app.note_scroll, u16::MAX);
+        app.handle_view_note(key(KeyCode::Home), &mut items);
+        assert_eq!(app.note_scroll, 0);
+        app.handle_view_note(key(KeyCode::Char('g')), &mut items);
+        assert_eq!(app.note_scroll, 0);
+    }
+
+    #[test]
+    fn view_note_e_opens_the_editor() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "# body")];
+        let mut items = vec![];
+
+        app.handle_view_note(key(KeyCode::Char('e')), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::EditNote);
+        let textarea = app.note_textarea.as_ref().unwrap();
+        assert_eq!(textarea.lines(), &["# body"]);
+    }
+
+    #[test]
+    fn view_note_h_opens_help() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut items = vec![];
+
+        app.handle_view_note(key(KeyCode::Char('h')), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewHelp);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewNote);
+    }
+
+    #[test]
+    fn view_note_esc_returns_to_the_list() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut items = vec![];
+        Note::load_items(&mut app, &mut items);
+        items.clear();
+
+        app.handle_view_note(key(KeyCode::Enter), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(items.len(), 1); // list refreshed
+    }
+
+    #[test]
+    fn view_note_e_with_an_empty_body_starts_with_one_line() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut items = vec![];
+
+        app.handle_view_note(key(KeyCode::Char('e')), &mut items);
+
+        assert_eq!(app.view_mode, ViewMode::EditNote);
+        assert_eq!(
+            app.note_textarea.as_ref().unwrap().lines(),
+            &["".to_string()]
+        );
+    }
+
+    #[test]
+    fn view_note_unknown_keys_do_nothing() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut items = vec![];
+
+        let action = app.handle_view_note(key(KeyCode::Char('z')), &mut items);
+
+        assert_eq!(action, KeyAction::None);
+    }
+
+    #[test]
+    fn view_note_q_quits() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        let mut items = vec![];
+
+        assert_eq!(
+            app.handle_view_note(key(KeyCode::Char('q')), &mut items),
+            KeyAction::Quit
+        );
+    }
+
+    #[test]
+    fn edit_note_esc_saves_changes_and_returns_to_the_preview() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "old")];
+        app.note_textarea = Some(TextArea::from(vec!["new body".to_string()]));
+
+        app.handle_edit_note(key(KeyCode::Esc));
+
+        assert_eq!(app.view_mode, ViewMode::ViewNote);
+        assert!(app.note_textarea.is_none());
+        assert_eq!(app.notes[0].body, "new body");
+        assert!(app.notes[0].updated_at.is_some());
+    }
+
+    #[test]
+    fn edit_note_esc_without_changes_skips_the_write() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+        app.note_textarea = Some(TextArea::from(vec![String::new()]));
+
+        app.handle_edit_note(key(KeyCode::Esc));
+
+        assert_eq!(app.view_mode, ViewMode::ViewNote);
+        assert_eq!(app.notes[0].updated_at, None);
+    }
+
+    #[test]
+    fn edit_note_esc_without_a_textarea_returns() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![note("n", "")];
+
+        app.handle_edit_note(key(KeyCode::Esc));
+
+        assert_eq!(app.view_mode, ViewMode::ViewNote);
+    }
+
+    #[test]
+    fn edit_note_other_keys_go_to_the_textarea() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::EditNote;
+        app.notes = vec![note("n", "")];
+        app.note_textarea = Some(TextArea::from(vec![String::new()]));
+
+        app.handle_edit_note(key(KeyCode::Char('a')));
+
+        assert_eq!(app.view_mode, ViewMode::EditNote);
+        assert_eq!(
+            app.note_textarea.as_ref().unwrap().lines(),
+            &["a".to_string()]
+        );
+    }
+
+    // ---- handle_modal_nav ----
+
+    #[test]
+    fn delete_project_leaves_a_countdown_untouched() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        app.selected_project_index.select(Some(1));
+        app.timer = Some(paused_countdown(60, 10)); // not bound to any task
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        assert!(app.timer.is_some());
+        assert_eq!(app.timer.as_ref().unwrap().kind, TimerKind::Countdown);
+    }
+
+    #[test]
+    fn rename_task_without_a_timer_is_fine() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut input = input_with("renamed");
+
+        app.handle_rename_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert!(app.timer.is_none());
+        assert_eq!(Task::get_current(&app).title, "renamed");
+    }
+
+    #[test]
+    fn timer_task_space_without_a_timer_is_a_no_op() {
+        let mut app = make_app(vec![]);
+
+        app.handle_timer_task(key(KeyCode::Char(' '))); // must not panic
+
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn delete_project_keeps_a_timer_bound_to_an_earlier_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![
+            Project {
+                title: "a".to_string(),
+                tasks: vec![],
+            },
+            Project {
+                title: "b".to_string(),
+                tasks: vec![],
+            },
+        ]);
+        app.selected_project_index.select(Some(1)); // delete "b"
+        app.timer = Some(paused_stopwatch(10, 0, "t")); // bound to "a"
+        let mut items = vec![];
+
+        app.handle_delete_project(key(KeyCode::Enter), &mut items);
+
+        let bound = app.timer.as_ref().unwrap().bound.as_ref().unwrap();
+        assert_eq!(bound.project_index, 0); // unchanged
+    }
+
+    #[test]
+    fn rename_task_leaves_a_timer_bound_to_another_task_alone() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.timer = Some(paused_stopwatch(10, 0, "other task"));
+        let mut input = input_with("renamed");
+
+        app.handle_rename_task(key(KeyCode::Enter), &mut input, &mut items);
+
+        assert_eq!(
+            app.timer
+                .as_ref()
+                .unwrap()
+                .bound
+                .as_ref()
+                .unwrap()
+                .task_title,
+            "other task"
+        );
+    }
+
+    #[test]
+    fn next_and_previous_with_no_selection_start_at_zero() {
+        let mut app = make_app(vec![]);
+        let items: Vec<ListItem> = vec![ListItem::from("a"), ListItem::from("b")];
+        app.selected_project_index.select(None);
+
+        app.next(&items);
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+
+        app.selected_project_index.select(None);
+        app.previous(&items);
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn board_sync_without_a_selection_is_a_no_op() {
+        let mut app = tasks_app();
+        app.selected_task_index.select(None);
+
+        app.board_sync(); // must not panic
+
+        assert_eq!(app.board_lane, 0);
+    }
+
+    #[test]
+    fn board_sync_with_an_out_of_range_project_is_a_no_op() {
+        let mut app = tasks_app();
+        app.selected_project_index.select(Some(5)); // only one project
+
+        app.board_sync(); // must not panic
+
+        assert_eq!(app.board_lane, 0);
+    }
+
+    #[test]
+    fn board_sync_with_an_unknown_status_keeps_the_current_lane() {
+        let mut app = tasks_app();
+        app.selected_task_index.select(Some(0));
+        app.projects[0].tasks[0].status = "Bogus".to_string();
+        app.board_lane = 2;
+
+        app.board_sync(); // must not panic
+
+        assert_eq!(app.board_lane, 2);
+    }
+
+    #[test]
+    fn board_move_on_an_empty_lane_is_a_no_op() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.board_lane = 2; // Done lane is empty
+
+        app.board_move(true);
+        app.board_move(false);
+
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn modal_nav_esc_resets_and_returns() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::DeleteProject;
+        app.delete_confirm_index.select(Some(1));
+        let items = confirm_items();
+
+        let handled = app.handle_modal_nav(KeyCode::Esc, &items, ViewMode::ViewProjects);
+
+        assert!(handled);
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.delete_confirm_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn modal_nav_keys_move_the_selection() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::DeleteProject;
+        let items = confirm_items();
+
+        assert!(app.handle_modal_nav(KeyCode::Down, &items, ViewMode::ViewProjects));
+        assert_eq!(app.delete_confirm_index.selected(), Some(1));
+        assert!(app.handle_modal_nav(KeyCode::Tab, &items, ViewMode::ViewProjects));
+        assert_eq!(app.delete_confirm_index.selected(), Some(0)); // next wraps
+        assert!(app.handle_modal_nav(KeyCode::BackTab, &items, ViewMode::ViewProjects));
+        assert_eq!(app.delete_confirm_index.selected(), Some(1)); // previous wraps
+        assert!(app.handle_modal_nav(KeyCode::Char('j'), &items, ViewMode::ViewProjects));
+        assert_eq!(app.delete_confirm_index.selected(), Some(0));
+        assert!(app.handle_modal_nav(KeyCode::Char('k'), &items, ViewMode::ViewProjects));
+        assert_eq!(app.delete_confirm_index.selected(), Some(1));
+    }
+
+    #[test]
+    fn modal_nav_other_keys_are_not_handled() {
+        let mut app = make_app(vec![]);
+        let items = confirm_items();
+
+        assert!(!app.handle_modal_nav(KeyCode::Enter, &items, ViewMode::ViewProjects));
+    }
+
+    // ---- misc ----
+
+    #[test]
+    fn delete_current_task_moves_to_the_previous_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        app.selected_task_index.select(Some(1));
+
+        app.delete_current_task(&mut items);
+
+        assert_eq!(app.projects[0].tasks.len(), 1);
+        assert_eq!(app.selected_task_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn handle_key_dispatches_every_view_mode() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = tasks_app();
+        app.notes = vec![note("n", "")];
+        app.timer = Some(paused_countdown(60, 10));
+        let mut input = Input::default();
+        let mut items = vec![];
+        Task::load_items(&mut app, &mut items);
+        let mut status_items = vec![];
+        Task::load_statuses_items(&mut status_items);
+        let mut priority_items = vec![];
+        Task::load_priority_items(&mut priority_items);
+
+        let modes = [
+            ViewMode::ViewProjects,
+            ViewMode::RenameProject,
+            ViewMode::AddProject,
+            ViewMode::DeleteProject,
+            ViewMode::ViewTasks,
+            ViewMode::RenameTask,
+            ViewMode::ChangeStatusTask,
+            ViewMode::ChangePriorityTask,
+            ViewMode::AddTask,
+            ViewMode::DeleteTask,
+            ViewMode::ViewTaskDetails,
+            ViewMode::EditTaskNote,
+            ViewMode::SetTaskEstimate,
+            ViewMode::TimerTask,
+            ViewMode::SetCountdown,
+            ViewMode::ViewHelp,
+            ViewMode::ViewNotes,
+            ViewMode::AddNote,
+            ViewMode::RenameNote,
+            ViewMode::DeleteNote,
+            ViewMode::ViewNote,
+            ViewMode::EditNote,
+            ViewMode::InfoMigration,
+        ];
+
+        for mode in modes {
+            app.view_mode = mode;
+            app.handle_key(
+                key(KeyCode::Char('q')),
+                &mut input,
+                &mut items,
+                &status_items,
+                &priority_items,
+            );
+        }
+    }
+
+    #[test]
+    fn use_state_maps_the_remaining_view_modes() {
+        fn assert_state(app: &mut App, mode: ViewMode, expected: fn(&App) -> *const ListState) {
+            app.view_mode = mode;
+            let actual = app.use_state() as *const ListState;
+            assert_eq!(actual, expected(app));
+        }
+
+        let mut app = make_app(vec![]);
+
+        assert_state(&mut app, ViewMode::AddProject, |a| {
+            &a.selected_project_index
+        });
+        assert_state(&mut app, ViewMode::AddTask, |a| &a.selected_task_index);
+        assert_state(&mut app, ViewMode::EditTaskNote, |a| &a.selected_task_index);
+        assert_state(&mut app, ViewMode::SetTaskEstimate, |a| {
+            &a.selected_task_index
+        });
+        assert_state(&mut app, ViewMode::ViewHelp, |a| &a.selected_project_index);
+        assert_state(&mut app, ViewMode::InfoMigration, |a| {
+            &a.selected_project_index
+        });
+
+        // Help uses the selection state of the view it was opened from
+        app.previous_view_mode = ViewMode::ViewTasks;
+        assert_state(&mut app, ViewMode::ViewHelp, |a| &a.selected_task_index);
+        app.previous_view_mode = ViewMode::ViewNotes;
+        assert_state(&mut app, ViewMode::ViewHelp, |a| &a.selected_note_index);
+        app.previous_view_mode = ViewMode::ViewNote;
+        assert_state(&mut app, ViewMode::ViewHelp, |a| &a.selected_note_index);
+        app.previous_view_mode = ViewMode::ViewTaskDetails;
+        assert_state(&mut app, ViewMode::ViewHelp, |a| &a.selected_project_index);
+
+        app.previous_view_mode = ViewMode::ViewProjects;
+        assert_state(&mut app, ViewMode::TimerTask, |a| &a.selected_project_index);
+        assert_state(&mut app, ViewMode::SetCountdown, |a| {
+            &a.selected_project_index
+        });
+
+        app.previous_view_mode = ViewMode::ViewTasks;
+        assert_state(&mut app, ViewMode::TimerTask, |a| &a.selected_task_index);
+        assert_state(&mut app, ViewMode::SetCountdown, |a| &a.selected_task_index);
+    }
+}
+
+// ------------------------------------------------------------------------
+// Event loop (`run_with_source`)
+// ------------------------------------------------------------------------
+mod event_loop {
+    use super::*;
+    use crate::task::{TASK_PRIORITY_NONE, TASK_STATUS_DONE, TASK_STATUS_UP_NEXT};
+    use crate::test_utils::make_task;
+    use crate::CrosstermSource;
+    use ratatui::{backend::TestBackend, Terminal};
+    use std::collections::VecDeque;
+
+    struct QueuedKeys {
+        keys: VecDeque<Option<KeyEvent>>,
+    }
+
+    impl QueuedKeys {
+        fn from_keys(keys: Vec<KeyEvent>) -> Self {
+            Self {
+                keys: keys.into_iter().map(Some).collect(),
+            }
+        }
+    }
+
+    impl KeySource for QueuedKeys {
+        fn next_key(&mut self) -> io::Result<Option<KeyEvent>> {
+            Ok(self.keys.pop_front().flatten())
+        }
+    }
+
+    fn run(app: &mut App, keys: Vec<KeyEvent>, migrations: bool) -> io::Result<()> {
+        let backend = TestBackend::new(80, 24);
+        let terminal = Terminal::new(backend).unwrap();
+        let mut source = QueuedKeys::from_keys(keys);
+        app.run_with_source(terminal, migrations, &mut source)
+    }
+
+    #[test]
+    fn quit_key_ends_the_loop() {
+        let mut app = make_app(vec![]);
+
+        let result = run(&mut app, vec![key(KeyCode::Char('q'))], false);
+
+        assert!(result.is_ok());
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn crossterm_source_polls_without_panicking() {
+        let mut source = CrosstermSource;
+        // On CI stdin is /dev/null (no events); on a local tty this waits
+        // up to 250 ms and returns `None` unless the user happens to type.
+        // Either outcome is fine — the poll itself must not panic.
+        let _ = source.next_key();
+    }
+
+    #[test]
+    fn applied_migrations_start_in_the_info_view() {
+        let mut app = make_app(vec![]);
+
+        let result = run(
+            &mut app,
+            vec![key(KeyCode::Char('x')), key(KeyCode::Char('q'))],
+            true,
+        );
+
+        assert!(result.is_ok());
+        // 'x' dismissed the migration info, 'q' quit from ViewProjects
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn skip_keys_redraw_and_continue() {
+        let mut app = make_app(vec![]); // no projects: Enter skips
+
+        let result = run(
+            &mut app,
+            vec![key(KeyCode::Enter), key(KeyCode::Char('q'))],
+            false,
+        );
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn timeouts_tick_the_timer_without_input() {
+        let mut app = make_app(vec![]);
+        let mut source = QueuedKeys {
+            keys: VecDeque::from([None, None, Some(key(KeyCode::Char('q')))]),
+        };
+        let backend = TestBackend::new(80, 24);
+        let terminal = Terminal::new(backend).unwrap();
+
+        let result = app.run_with_source(terminal, false, &mut source);
+
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn help_over_an_all_done_task_list_does_not_panic() {
+        // Regression: when every task is done (and done tasks are
+        // hidden), the task list is empty. Opening help must not
+        // corrupt the project selection — ratatui clears the state of
+        // an empty list on render, which used to wipe
+        // `selected_project_index` and panic in `Project::get_current`
+        // on the next frame.
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_DONE, TASK_PRIORITY_NONE)],
+        }]);
+
+        let result = run(
+            &mut app,
+            vec![
+                key(KeyCode::Enter),
+                key(KeyCode::Char('h')),
+                key(KeyCode::Char('x')),
+                key(KeyCode::Char('q')),
+            ],
+            false,
+        );
+
+        assert!(result.is_ok());
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+    }
+
+    struct ExhaustiveKeys {
+        keys: VecDeque<Option<KeyEvent>>,
+    }
+
+    impl KeySource for ExhaustiveKeys {
+        fn next_key(&mut self) -> io::Result<Option<KeyEvent>> {
+            match self.keys.pop_front() {
+                Some(k) => Ok(k),
+                // End the loop once the scripted keys are used up —
+                // a bare `None` would tick forever.
+                None => Err(io::Error::other("keys exhausted")),
+            }
+        }
+    }
+
+    /// Brute-force smoke test: random key sequences over projects with
+    /// all-done / empty / mixed task lists must never panic. Guards the
+    /// selection-state invariants (ratatui clears or clamps the state of
+    /// a list rendered empty/short, so a view using the wrong `ListState`
+    /// corrupts it).
+    #[test]
+    fn fuzz_random_keys_never_panics() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let pool = [
+            KeyCode::Char('h'),
+            KeyCode::Enter,
+            KeyCode::Esc,
+            KeyCode::Left,
+            KeyCode::Right,
+            KeyCode::Up,
+            KeyCode::Down,
+            KeyCode::Char('b'),
+            KeyCode::Char('t'),
+            KeyCode::Char('n'),
+            KeyCode::Char('r'),
+            KeyCode::Char('d'),
+            KeyCode::Char('v'),
+            KeyCode::Char('e'),
+            KeyCode::Char('p'),
+            KeyCode::Char('s'),
+            KeyCode::Char('c'),
+            KeyCode::Char('m'),
+            KeyCode::Char('j'),
+            KeyCode::Char('k'),
+            KeyCode::Char('g'),
+            KeyCode::Char('1'),
+            KeyCode::Char(' '),
+            KeyCode::Tab,
+            KeyCode::BackTab,
+            KeyCode::Char('x'),
+            KeyCode::Char('q'),
+        ];
+        let mut seed: u64 = 0x1234_5678_9abc_def0;
+        let mut next = move || {
+            seed ^= seed << 13;
+            seed ^= seed >> 7;
+            seed ^= seed << 17;
+            seed
+        };
+
+        for round in 0..300 {
+            let mut app = make_app(vec![
+                Project {
+                    title: "all done".to_string(),
+                    tasks: vec![
+                        make_task("t1", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+                        make_task("t2", TASK_STATUS_DONE, 1),
+                    ],
+                },
+                Project {
+                    title: "empty".to_string(),
+                    tasks: vec![],
+                },
+                Project {
+                    title: "mixed".to_string(),
+                    tasks: vec![
+                        make_task("m1", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                        make_task("m2", TASK_STATUS_DONE, 2),
+                    ],
+                },
+            ]);
+            let keys: Vec<KeyEvent> = (0..40)
+                .map(|_| key(pool[(next() % pool.len() as u64) as usize]))
+                .collect();
+            let result = std::panic::catch_unwind(std::panic::AssertUnwindSafe(|| {
+                let backend = TestBackend::new(80, 24);
+                let terminal = Terminal::new(backend).unwrap();
+                let mut source = ExhaustiveKeys {
+                    keys: keys.clone().into_iter().map(Some).collect(),
+                };
+                let _ = app.run_with_source(terminal, false, &mut source);
+            }));
+            if result.is_err() {
+                panic!(
+                    "round {round} panicked with keys: {:?}",
+                    keys.iter().map(|k| k.code).collect::<Vec<_>>()
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn release_events_are_ignored() {
+        let mut app = make_app(vec![]);
+        // If the Release event were handled, 'n' would open AddProject and
+        // the following 'q' would just be input text — the loop would not
+        // terminate, so reaching the end proves the filter works.
+        let keys = vec![release_key(KeyCode::Char('n')), key(KeyCode::Char('q'))];
+
+        let result = run(&mut app, keys, false);
+
+        assert!(result.is_ok());
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn quitting_settles_a_running_stopwatch() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.timer = Some(paused_stopwatch(45, 0, "t"));
+
+        let result = run(&mut app, vec![key(KeyCode::Char('q'))], false);
+
+        assert!(result.is_ok());
+        assert!(app.timer.is_none());
+        assert_eq!(app.projects[0].tasks[0].time_spent_secs, 45);
+    }
+}
+
+// ------------------------------------------------------------------------
+// Timer behaviour (tick / settle / navigation helpers)
+// ------------------------------------------------------------------------
+mod timer_behaviour {
+    use super::*;
+    use crate::task::{TASK_PRIORITY_NONE, TASK_STATUS_UP_NEXT};
+    use crate::test_utils::make_task;
+
+    #[test]
+    fn tick_timer_rings_the_bell_once_at_zero() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(60, 60));
+
+        app.tick_timer();
+        assert!(app.timer.as_ref().unwrap().rung);
+
+        // Already rung: nothing more happens (and it must not panic)
+        app.tick_timer();
+        assert!(app.timer.as_ref().unwrap().rung);
+    }
+
+    #[test]
+    fn tick_timer_does_nothing_without_a_timer() {
+        let mut app = make_app(vec![]);
+
+        app.tick_timer();
+
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn tick_timer_ignores_running_timers() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(TimerState::new_stopwatch(0, "t".to_string()));
+
+        app.tick_timer();
+
+        assert!(!app.timer.as_ref().unwrap().rung);
+    }
+
+    #[test]
+    fn settle_timer_accumulates_stopwatch_seconds_into_the_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.timer = Some(paused_stopwatch(90, 0, "t"));
+
+        app.settle_timer();
+
+        assert!(app.timer.is_none());
+        assert_eq!(app.projects[0].tasks[0].time_spent_secs, 90);
+    }
+
+    #[test]
+    fn settle_timer_discards_a_countdown() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(60, 10));
+
+        app.settle_timer();
+
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn back_to_previous_view_restores_and_resets() {
+        let mut app = make_app(vec![]);
+        app.previous_view_mode = ViewMode::ViewNotes;
+
+        app.back_to_previous_view();
+
+        assert_eq!(app.view_mode, ViewMode::ViewNotes);
+        assert_eq!(app.previous_view_mode, ViewMode::ViewProjects);
+    }
+
+    #[test]
+    fn setup_reads_persisted_state() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+
+        let app = App::setup().unwrap();
+
+        assert!(app.projects.is_empty());
+        assert!(app.notes.is_empty());
+        assert_eq!(app.view_mode, ViewMode::ViewProjects);
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+        assert!(app.hide_done_tasks);
+        assert!(!app.board_view);
+        assert!(app.timer.is_none());
+    }
+
+    #[test]
+    fn setup_errors_on_a_corrupt_data_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        std::fs::write(Json::get_data_path(), "{ not json").unwrap();
+
+        assert!(App::setup().is_err());
+    }
+}
+
+// ------------------------------------------------------------------------
+// Rendering (all view modes, hint readouts, modal content)
+// ------------------------------------------------------------------------
+mod render {
+    use super::*;
+    use crate::task::{
+        TASK_PRIORITY_NONE, TASK_STATUS_DONE, TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT,
+    };
+    use crate::test_utils::make_task;
+    use ratatui::{backend::TestBackend, Terminal};
+
+    fn draw_with(app: &mut App, input: &Input, width: u16, height: u16) -> String {
+        let backend = TestBackend::new(width, height);
+        let mut terminal = Terminal::new(backend).unwrap();
+        let mut items = vec![];
+        Project::load_items(app, &mut items);
+        let mut status_items = vec![];
+        Task::load_statuses_items(&mut status_items);
+        let mut priority_items = vec![];
+        Task::load_priority_items(&mut priority_items);
+
+        let frame = terminal
+            .draw(|f| app.render(f, f.size(), input, &items, &status_items, &priority_items))
+            .unwrap();
+
+        frame.buffer.content.iter().map(|c| c.symbol()).collect()
+    }
+
+    fn draw_text(app: &mut App, width: u16, height: u16) -> String {
+        let input = Input::default();
+        draw_with(app, &input, width, height)
+    }
+
+    #[test]
+    fn render_never_panics_in_any_view_mode() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![
+                make_task("a", TASK_STATUS_UP_NEXT, 1),
+                make_task("b", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+                make_task("c", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            ],
+        }]);
+        app.projects[0].tasks[0].note = "note".to_string();
+        app.projects[0].tasks[1].estimated_hours = 2;
+        app.notes = vec![note("n", "# hi")];
+        app.timer = Some(paused_countdown(60, 30));
+
+        let modes = [
+            ViewMode::ViewProjects,
+            ViewMode::RenameProject,
+            ViewMode::AddProject,
+            ViewMode::DeleteProject,
+            ViewMode::ViewTasks,
+            ViewMode::RenameTask,
+            ViewMode::ChangeStatusTask,
+            ViewMode::ChangePriorityTask,
+            ViewMode::AddTask,
+            ViewMode::DeleteTask,
+            ViewMode::ViewTaskDetails,
+            ViewMode::EditTaskNote,
+            ViewMode::SetTaskEstimate,
+            ViewMode::TimerTask,
+            ViewMode::SetCountdown,
+            ViewMode::ViewHelp,
+            ViewMode::ViewNotes,
+            ViewMode::AddNote,
+            ViewMode::RenameNote,
+            ViewMode::DeleteNote,
+            ViewMode::ViewNote,
+            ViewMode::EditNote,
+            ViewMode::InfoMigration,
+        ];
+
+        for mode in modes {
+            app.view_mode = mode;
+            app.previous_view_mode = ViewMode::ViewProjects;
+            draw_text(&mut app, 80, 24);
+            draw_text(&mut app, 40, 10); // tiny sizes must not panic either
+        }
+
+        // Board rendering goes through the same `show_items` path
+        app.view_mode = ViewMode::ViewTasks;
+        app.board_view = true;
+        app.selected_task_index.select(Some(0));
+        app.board_sync();
+        draw_text(&mut app, 80, 24);
+    }
+
+    #[test]
+    fn hint_shows_help_and_no_timer_readout_without_a_timer() {
+        let mut app = make_app(vec![]);
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains("h  help"));
+        assert!(!text.contains("pomodoro"));
+    }
+
+    #[test]
+    fn hint_renders_a_running_stopwatch() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(TimerState::new_stopwatch(0, "t".to_string()));
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains('▶'));
+    }
+
+    #[test]
+    fn hint_renders_a_paused_stopwatch() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_stopwatch(65, 0, "short"));
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains("❚❚"));
+        assert!(text.contains("00:01:05"));
+        assert!(text.contains("short"));
+    }
+
+    #[test]
+    fn hint_truncates_long_task_titles_with_an_ellipsis() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_stopwatch(0, 0, &"x".repeat(30)));
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains('…'));
+        assert_eq!(text.matches('x').count(), 20);
+    }
+
+    #[test]
+    fn hint_renders_a_low_running_countdown() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(TimerState::new_countdown(10)); // ~10s left
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains('▼'));
+    }
+
+    #[test]
+    fn hint_renders_an_unbound_timer_as_pomodoro() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(600, 60));
+
+        let text = draw_text(&mut app, 120, 60);
+
+        assert!(text.contains("pomodoro"));
+        assert!(text.contains("00:09:00"));
+    }
+
+    #[test]
+    fn timer_modal_running_countdown_turns_red_when_low() {
+        let mut app = make_app(vec![]);
+        // Running (started just now) with ~10s left: red readout
+        app.timer = Some(TimerState::new_countdown(10));
+        app.view_mode = ViewMode::TimerTask;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("running"));
+        assert!(text.contains("█"));
+    }
+
+    #[test]
+    fn timer_modal_running_countdown_is_green_when_plenty_left() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(TimerState::new_countdown(600));
+        app.view_mode = ViewMode::TimerTask;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("running"));
+    }
+
+    #[test]
+    fn timer_modal_stopwatch_shows_an_over_estimate_in_red() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.projects[0].tasks[0].estimated_hours = 1;
+        app.projects[0].tasks[0].time_spent_secs = 7200; // 200%
+        app.timer = Some(paused_stopwatch(0, 0, "t"));
+        app.view_mode = ViewMode::TimerTask;
+        app.previous_view_mode = ViewMode::ViewTasks;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("1h (200% spent)"));
+    }
+
+    #[test]
+    fn timer_modal_bound_without_an_estimate_hides_the_estimate_line() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.timer = Some(paused_stopwatch(0, 0, "t"));
+        app.view_mode = ViewMode::TimerTask;
+        app.previous_view_mode = ViewMode::ViewTasks;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Task: t"));
+        assert!(!text.contains("Estimate:"));
+    }
+
+    #[test]
+    fn timer_modal_finished_countdown_shows_time_is_up() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(60, 60)); // finished
+        app.view_mode = ViewMode::TimerTask;
+        app.previous_view_mode = ViewMode::ViewProjects;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("time's up!"));
+        assert!(text.contains("Press any key to close"));
+    }
+
+    #[test]
+    fn timer_modal_stopwatch_shows_estimate_progress() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.projects[0].tasks[0].estimated_hours = 2; // 7200s
+        app.projects[0].tasks[0].time_spent_secs = 3600; // 50%
+        app.timer = Some(paused_stopwatch(0, 0, "t"));
+        app.view_mode = ViewMode::TimerTask;
+        app.previous_view_mode = ViewMode::ViewTasks;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Task: t"));
+        assert!(text.contains("Estimate:"));
+        assert!(text.contains("2h (50% spent)"));
+    }
+
+    #[test]
+    fn timer_modal_countdown_shows_the_target() {
+        let mut app = make_app(vec![]);
+        app.timer = Some(paused_countdown(1500, 600));
+        app.view_mode = ViewMode::TimerTask;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Pomodoro"));
+        assert!(text.contains("of 00:25:00"));
+        // The readout itself is rendered as block digits
+        assert!(text.contains("█"));
+    }
+
+    #[test]
+    fn timer_modal_handles_a_missing_timer_gracefully() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::TimerTask;
+
+        draw_text(&mut app, 80, 24); // must not panic
+    }
+
+    #[test]
+    fn details_modal_renders_all_task_fields() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_ON_GOING, 2)],
+        }]);
+        app.projects[0].tasks[0].created_at = Some(1_700_000_000);
+        app.projects[0].tasks[0].completed_at = Some(1_700_000_100);
+        app.projects[0].tasks[0].note = "a note".to_string();
+        app.projects[0].tasks[0].time_spent_secs = 5400; // 1h 30m
+        app.projects[0].tasks[0].estimated_hours = 3; // 50% of 3h
+        app.view_mode = ViewMode::ViewTaskDetails;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Task: t"));
+        assert!(text.contains("Status: OnGoing"));
+        assert!(text.contains("Priority: 2 (!!)"));
+        assert!(text.contains("Note: a note"));
+        assert!(text.contains("Created:"));
+        assert!(text.contains("Completed:"));
+        assert!(text.contains("Time Consumed:"));
+        assert!(text.contains("Time Spent:"));
+        assert!(text.contains("1h 30m"));
+        assert!(text.contains("Estimate: 3h (50% spent)"));
+    }
+
+    #[test]
+    fn details_modal_without_dates_or_estimate() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.projects[0].tasks[0].created_at = None;
+        app.projects[0].tasks[0].completed_at = None;
+        app.view_mode = ViewMode::ViewTaskDetails;
+
+        let text = draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Priority: None"));
+        assert!(text.contains("Estimate: none"));
+        assert!(!text.contains("Created:"));
+        assert!(!text.contains("Completed:"));
+    }
+
+    #[test]
+    fn delete_modal_titles_the_selected_item() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "proj".to_string(),
+            tasks: vec![make_task("task", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.notes = vec![note("note", "")];
+
+        app.view_mode = ViewMode::DeleteTask;
+        assert!(draw_text(&mut app, 80, 24).contains("Delete \"task\"?"));
+
+        app.view_mode = ViewMode::DeleteProject;
+        assert!(draw_text(&mut app, 80, 24).contains("Delete \"proj\"?"));
+
+        app.view_mode = ViewMode::DeleteNote;
+        assert!(draw_text(&mut app, 80, 24).contains("Delete \"note\"?"));
+    }
+
+    #[test]
+    fn help_over_an_empty_task_list_keeps_the_project_selection() {
+        // Regression: entering a project with no tasks, opening help, and
+        // letting the loop redraw used to clear `selected_project_index`
+        // (the empty task list was rendered with the project state) and
+        // panic in `Project::get_current` on the next frame.
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![],
+        }]);
+        let backend = TestBackend::new(80, 24);
+        let mut terminal = Terminal::new(backend).unwrap();
+        let mut input = Input::default();
+        let mut items = vec![];
+        Project::load_items(&mut app, &mut items);
+        let mut status_items = vec![];
+        Task::load_statuses_items(&mut status_items);
+        let mut priority_items = vec![];
+        Task::load_priority_items(&mut priority_items);
+
+        // projects -> Enter -> tasks (empty) -> h -> help
+        app.handle_view_projects(key(KeyCode::Enter), &mut input, &mut items);
+        app.handle_view_tasks(key(KeyCode::Char('h')), &mut input, &mut items);
+
+        for _ in 0..3 {
+            terminal
+                .draw(|f| app.render(f, f.size(), &input, &items, &status_items, &priority_items))
+                .unwrap();
+        }
+
+        assert_eq!(app.view_mode, ViewMode::ViewHelp);
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn help_over_an_empty_notes_list_keeps_the_project_selection() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]); // no projects and no notes
+        app.view_mode = ViewMode::ViewHelp;
+        app.previous_view_mode = ViewMode::ViewNotes;
+
+        let text = draw_text(&mut app, 80, 24);
+        draw_text(&mut app, 80, 24);
+
+        assert!(text.contains("Press any key to close"));
+        assert_eq!(app.selected_project_index.selected(), Some(0));
+    }
+
+    #[test]
+    fn help_modal_lists_the_bindings_of_the_previous_view() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.view_mode = ViewMode::ViewHelp;
+
+        app.previous_view_mode = ViewMode::ViewProjects;
+        assert!(draw_text(&mut app, 80, 24).contains("go to tasks"));
+
+        app.previous_view_mode = ViewMode::ViewNotes;
+        assert!(draw_text(&mut app, 80, 24).contains("preview"));
+
+        app.previous_view_mode = ViewMode::ViewNote;
+        assert!(draw_text(&mut app, 80, 24).contains("scroll"));
+
+        app.previous_view_mode = ViewMode::ViewTasks;
+        app.board_view = false;
+        assert!(draw_text(&mut app, 80, 24).contains("toggle done"));
+
+        app.board_view = true;
+        assert!(draw_text(&mut app, 80, 24).contains("switch lane"));
+
+        app.previous_view_mode = ViewMode::ViewTaskDetails; // no bindings
+        assert!(draw_text(&mut app, 80, 24).contains("Press any key to close"));
+    }
+
+    #[test]
+    fn input_modal_scrolls_a_long_value() {
+        let mut app = make_app(vec![]);
+        app.view_mode = ViewMode::AddProject;
+        let input = input_with(&"x".repeat(200));
+
+        let text = draw_with(&mut app, &input, 40, 10);
+
+        assert!(text.contains(&"x".repeat(30)));
+    }
+}
diff --git a/src/cli.rs b/src/cli.rs
index f41bb91..6dd4176 100644
--- a/src/cli.rs
+++ b/src/cli.rs
@@ -1,20 +1,84 @@
-use std::{env, process::exit};
-
 pub struct Cli;
 
-impl Cli {
-    pub fn read() {
-        // If you use `cargo run main.rs`, skip must be 2
-        let mut args = env::args().skip(1);
+/// What the program should do based on its command-line arguments.
+#[derive(Debug, PartialEq, Eq)]
+pub enum CliAction {
+    Run,
+    ShowVersion,
+    ShowHelp,
+}
+
+pub const USAGE: &str = "basilk - a TUI kanban task manager
+
+Usage: basilk [OPTIONS]
 
+Options:
+  -h, --help     Print this help message and exit
+      --version  Print the version and exit
+";
+
+impl Cli {
+    /// Decide what to do from the command-line arguments (without the
+    /// program name, which is always the first argument).
+    pub fn parse(mut args: impl Iterator<Item = String>) -> CliAction {
         match args.next() {
-            Some(arg) => {
-                if arg == "--version" {
-                    print!(env!("CARGO_PKG_VERSION"));
-                    exit(0)
-                }
-            }
-            None => (),
+            Some(arg) if arg == "--version" => CliAction::ShowVersion,
+            Some(arg) if arg == "--help" || arg == "-h" => CliAction::ShowHelp,
+            _ => CliAction::Run,
         }
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn no_arguments_means_run() {
+        assert_eq!(Cli::parse(std::iter::empty()), CliAction::Run);
+    }
+
+    #[test]
+    fn version_flag_is_recognized() {
+        assert_eq!(
+            Cli::parse(["--version".to_string()].into_iter()),
+            CliAction::ShowVersion
+        );
+    }
+
+    #[test]
+    fn help_flags_are_recognized() {
+        assert_eq!(
+            Cli::parse(["--help".to_string()].into_iter()),
+            CliAction::ShowHelp
+        );
+        assert_eq!(
+            Cli::parse(["-h".to_string()].into_iter()),
+            CliAction::ShowHelp
+        );
+    }
+
+    #[test]
+    fn usage_mentions_the_program_and_every_flag() {
+        assert!(USAGE.contains("basilk"));
+        assert!(USAGE.contains("--version"));
+        assert!(USAGE.contains("--help"));
+    }
+
+    #[test]
+    fn unknown_arguments_are_ignored() {
+        assert_eq!(
+            Cli::parse(["--nope".to_string()].into_iter()),
+            CliAction::Run
+        );
+        assert_eq!(
+            Cli::parse(["basilk".to_string()].into_iter()),
+            CliAction::Run
+        );
+        // Only the first argument counts
+        assert_eq!(
+            Cli::parse(["basilk".to_string(), "--version".to_string()].into_iter()),
+            CliAction::Run
+        );
+    }
+}
diff --git a/src/config.rs b/src/config.rs
deleted file mode 100644
index 3a400e1..0000000
--- a/src/config.rs
+++ /dev/null
@@ -1,70 +0,0 @@
-use std::{
-    fs::{self, File},
-    io::Write,
-    path::PathBuf,
-    process::exit,
-};
-
-use serde::{Deserialize, Serialize};
-
-use crate::json::Json;
-
-#[derive(Deserialize, Serialize)]
-pub struct ConfigToml {
-    pub ui: Ui,
-}
-
-#[derive(Deserialize, Serialize)]
-pub struct Ui {
-    pub show_help: bool,
-}
-
-pub struct Config;
-
-static CONFIG_FILE_NAME: &str = "config";
-
-impl Config {
-    fn get_default() -> ConfigToml {
-        ConfigToml {
-            ui: Ui { show_help: true },
-        }
-    }
-
-    fn get_config_path() -> PathBuf {
-        let mut path = PathBuf::new();
-        path.push(Json::get_dir_path().as_path());
-        path.push(format!("{CONFIG_FILE_NAME}.toml"));
-
-        return path;
-    }
-
-    pub fn read() -> ConfigToml {
-        let path = Config::get_config_path();
-        let config_raw = match fs::read_to_string(&path) {
-            Ok(c) => c,
-            // If config.toml file doesn't exist, create it by default
-            Err(_) => {
-                let default_config = toml::to_string(&Config::get_default()).unwrap();
-
-                let mut file = File::create(&path).unwrap();
-                let _ = file.write_all(default_config.as_bytes());
-
-                default_config
-            }
-        };
-
-        let data: ConfigToml = match toml::from_str(&config_raw) {
-            Ok(c) => c,
-            // If config.toml is not valid, throw a error message
-            Err(_) => {
-                eprint!(
-                    "{} - ERROR: The configuration file is invalid. Please check the wiki for correct formatting or delete the file",
-                    env!("CARGO_PKG_NAME")
-                );
-                exit(1)
-            }
-        };
-
-        return data;
-    }
-}
diff --git a/src/json.rs b/src/json.rs
index ae4a369..9597f82 100644
--- a/src/json.rs
+++ b/src/json.rs
@@ -1,29 +1,55 @@
-use std::{
-    error::Error,
-    fs::{self, File},
-    io::Write,
-    path::{Path, PathBuf},
-    sync::Mutex,
-};
+use std::{error::Error, fs, io, path::PathBuf};
 
-use serde_json::{from_str, to_string, Value};
+use serde::{Deserialize, Serialize};
+use serde_json::{from_str, to_string};
 
 use crate::{
     migration::{Migration, JSON_VERSIONS},
+    note::Note,
     project::Project,
 };
 
 pub struct Json;
 
 static DIR_CONFIG_NAME: &str = env!("CARGO_PKG_NAME");
-static VERSION: Mutex<String> = Mutex::new(String::new());
+static DATA_FILE_NAME: &str = "basilk_data.json";
+
+#[derive(Serialize, Deserialize)]
+struct DataWrapper {
+    version: String,
+    data: Vec<Project>,
+    /// Global notes; `default` keeps pre-notes data files loadable.
+    #[serde(default)]
+    notes: Vec<Note>,
+}
+
+/// Borrowed view of `DataWrapper` for serialization, so the write paths
+/// do not deep-copy projects and notes.
+#[derive(Serialize)]
+struct DataWrapperRef<'a> {
+    version: &'a str,
+    data: &'a [Project],
+    notes: &'a [Note],
+}
 
 impl Json {
     pub fn get_dir_path() -> PathBuf {
+        if let Ok(dir) = std::env::var("BASILK_CONFIG_DIR") {
+            return PathBuf::from(dir);
+        }
+
         let mut path = dirs::config_dir().unwrap();
         path.push(DIR_CONFIG_NAME);
 
-        return path;
+        path
+    }
+
+    pub(crate) fn get_data_path() -> PathBuf {
+        let mut path = PathBuf::new();
+        path.push(Json::get_dir_path().as_path());
+        path.push(DATA_FILE_NAME);
+
+        path
     }
 
     fn get_json_path(version: String) -> PathBuf {
@@ -31,84 +57,421 @@ impl Json {
         path.push(Json::get_dir_path().as_path());
         path.push(format!("{version}.json"));
 
-        return path;
+        path
     }
 
+    /// Bring the data file up to date: migrate the current file in place,
+    /// or bootstrap it from the legacy versioned files.
     pub fn check() -> Result<bool, Box<dyn Error>> {
         fs::create_dir_all(Json::get_dir_path())?;
+        let data_path = Json::get_data_path();
 
-        // Create the state to save the json version
-        let mut version_state = VERSION.lock().unwrap();
-
-        // Pick the version from the internal file
-        let mut json_version_from_file: Vec<&str> = JSON_VERSIONS
-            .into_iter()
-            .filter(|version| Path::new(&Json::get_json_path(version.to_string())).is_file())
-            .collect();
+        if data_path.is_file() {
+            Json::check_data_file(&data_path)
+        } else {
+            Json::check_legacy_files(&data_path)
+        }
+    }
 
-        // If the file doesn't exist create a new one with the last version
-        if json_version_from_file.is_empty() {
-            let last_json_version = JSON_VERSIONS.last().unwrap();
-            let path = Json::get_json_path(last_json_version.to_string());
+    /// The current data file exists. An empty file is reset to the latest
+    /// version; otherwise any pending migrations are applied one by one.
+    fn check_data_file(data_path: &PathBuf) -> Result<bool, Box<dyn Error>> {
+        let json_raw = fs::read_to_string(data_path)?;
 
-            let mut file = File::create(path).unwrap();
-            let _ = file.write_all(b"[]");
+        if json_raw.trim().is_empty() {
+            Json::write_internal(data_path, JSON_VERSIONS.last().unwrap(), &[], &[])?;
+            return Ok(false);
+        }
 
-            json_version_from_file = vec![last_json_version];
-            version_state.push_str(json_version_from_file[0]);
+        let wrapper: DataWrapper = from_str(&json_raw)?;
+        let migrations = Migration::get_migrations(&wrapper.version, wrapper.data);
 
+        if migrations.is_empty() {
             return Ok(false);
         }
 
-        // Save into the internal state the last json version
-        version_state.push_str(json_version_from_file[0]);
+        for (version, migration_data) in migrations {
+            Json::write_internal(data_path, version, &migration_data, &wrapper.notes)?;
+        }
+
+        Ok(true)
+    }
 
-        // Read the internal file
-        let path = Json::get_json_path(json_version_from_file[0].to_string());
-        let json_raw = fs::read_to_string(&path).unwrap();
-        let json = from_str::<Vec<Value>>(&json_raw).unwrap();
+    /// No current data file: migrate the oldest legacy versioned file into
+    /// the new format, or seed a fresh empty data file when none exists.
+    /// After a legacy migration the whole check re-runs to verify the new
+    /// file and apply any further migrations on top; the legacy file is
+    /// removed only once that verification passed.
+    fn check_legacy_files(data_path: &PathBuf) -> Result<bool, Box<dyn Error>> {
+        let old_version = JSON_VERSIONS
+            .into_iter()
+            .find(|version| Json::get_json_path(version.to_string()).is_file());
 
-        if json.is_empty() {
+        let Some(old_version) = old_version else {
+            Json::write_internal(data_path, JSON_VERSIONS.last().unwrap(), &[], &[])?;
             return Ok(false);
-        }
+        };
 
-        // Load all migrations
-        let migrations = Migration::get_migrations(json_version_from_file[0], json);
+        let old_path = Json::get_json_path(old_version.to_string());
+        let json_raw = fs::read_to_string(&old_path)?;
+        let data = from_str::<Vec<Project>>(&json_raw)?;
 
-        if migrations.is_empty() {
-            return Ok(false);
+        Json::write_internal(data_path, old_version, &data, &[])?;
+
+        // Verify the rewritten file (and apply further migrations) before
+        // removing the legacy copy.
+        let migrated = Json::check()?;
+
+        // Best-effort cleanup; a leftover legacy file is harmless.
+        let _ = fs::remove_file(old_path);
+
+        Ok(migrated)
+    }
+
+    /// Strict read of the on-disk wrapper: a missing file yields `None`,
+    /// while an unreadable or unparseable file is an error, so the write
+    /// paths never clobber corrupt data with an empty counterpart.
+    fn read_wrapper() -> Result<Option<DataWrapper>, Box<dyn Error>> {
+        let path = Json::get_data_path();
+        match fs::read_to_string(&path) {
+            Ok(json) => Ok(Some(from_str(&json)?)),
+            Err(e) if e.kind() == io::ErrorKind::NotFound => Ok(None),
+            Err(e) => Err(Box::new(e)),
         }
+    }
+
+    pub fn read() -> Result<Vec<Project>, Box<dyn Error>> {
+        Ok(Json::read_wrapper()?.map(|w| w.data).unwrap_or_default())
+    }
+
+    /// Write the project list, keeping the notes already on disk. Fails
+    /// without writing when the on-disk data cannot be parsed.
+    pub fn write(projects: &[Project]) -> Result<(), Box<dyn Error>> {
+        let path = Json::get_data_path();
+        let wrapper = Json::read_wrapper()?;
+        // A missing file is seeded at the latest version; an existing one
+        // keeps its version even when newer than this binary knows about.
+        let version = wrapper
+            .as_ref()
+            .map(|w| w.version.clone())
+            .unwrap_or_else(|| JSON_VERSIONS.last().unwrap().to_string());
+        let notes = wrapper.map(|w| w.notes).unwrap_or_default();
+
+        Json::write_internal(&path, &version, projects, &notes)
+    }
 
-        // Loop thru all migrations and apply them!
-        for (version, migration) in migrations.iter() {
-            let path = Json::get_json_path(version_state.to_string());
-            let new_path = Json::get_json_path(version.to_string());
+    /// Lenient startup read: a missing or unparseable file yields no notes.
+    pub fn read_notes() -> Vec<Note> {
+        Json::read_wrapper()
+            .ok()
+            .flatten()
+            .map(|wrapper| wrapper.notes)
+            .unwrap_or_default()
+    }
+
+    /// Write the note list, keeping the projects already on disk. Fails
+    /// without writing when the on-disk data cannot be parsed.
+    pub fn write_notes(notes: &[Note]) -> Result<(), Box<dyn Error>> {
+        let path = Json::get_data_path();
+        let wrapper = Json::read_wrapper()?;
+        // A missing file is seeded at the latest version; an existing one
+        // keeps its version even when newer than this binary knows about.
+        let version = wrapper
+            .as_ref()
+            .map(|w| w.version.clone())
+            .unwrap_or_else(|| JSON_VERSIONS.last().unwrap().to_string());
+        let projects = wrapper.map(|w| w.data).unwrap_or_default();
+
+        Json::write_internal(&path, &version, &projects, notes)
+    }
 
-            let new_json = migration;
+    fn write_internal(
+        path: &PathBuf,
+        version: &str,
+        data: &[Project],
+        notes: &[Note],
+    ) -> Result<(), Box<dyn Error>> {
+        let json = to_string(&DataWrapperRef {
+            version,
+            data,
+            notes,
+        })
+        .unwrap();
 
-            fs::write(&path, new_json).unwrap();
-            fs::rename(&path, new_path)?;
+        // Write to a temp file in the same directory and rename it over the
+        // target, so an interrupted write never leaves a truncated data file
+        // behind (the rename is atomic only within one filesystem).
+        let mut tmp_name = path.file_name().unwrap().to_os_string();
+        tmp_name.push(".tmp");
+        let tmp_path = path.with_file_name(tmp_name);
 
-            // Save into the internal state the json version of the last migration applied
-            version_state.clear();
-            version_state.push_str(&version)
+        if let Err(e) = fs::write(&tmp_path, &json).and_then(|()| fs::rename(&tmp_path, path)) {
+            let _ = fs::remove_file(&tmp_path);
+            return Err(format!("failed to write {}: {e}", path.display()).into());
         }
 
-        Ok(true)
+        Ok(())
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::note::Note;
+    use crate::task::{TASK_PRIORITY_NONE, TASK_STATUS_DONE};
+    use crate::test_utils::{make_task, ENV_LOCK};
 
-    pub fn read() -> Vec<Project> {
-        let version = VERSION.lock().unwrap().to_string();
-        let path = Json::get_json_path(version);
+    #[test]
+    fn check_creates_empty_data_file_and_read_returns_empty() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
 
-        let json = fs::read_to_string(path).unwrap();
-        return from_str::<Vec<Project>>(&json).unwrap();
+        let migrated = Json::check().unwrap();
+        assert!(!migrated);
+        assert!(Json::get_data_path().is_file());
+        assert_eq!(Json::read().unwrap(), vec![]);
     }
 
-    pub fn write(projects: Vec<Project>) {
-        let version = VERSION.lock().unwrap().to_string();
-        let path = Json::get_json_path(version);
+    #[test]
+    fn write_then_read_round_trips() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        let projects = vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_DONE, TASK_PRIORITY_NONE)],
+        }];
+
+        Json::write(&projects).unwrap();
+        assert_eq!(Json::read().unwrap(), projects);
+    }
+
+    #[test]
+    fn check_resets_an_empty_data_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+
+        fs::write(Json::get_data_path(), "  ").unwrap();
+        let migrated = Json::check().unwrap();
+
+        assert!(!migrated);
+        assert_eq!(Json::read().unwrap(), vec![]);
+    }
+
+    #[test]
+    fn notes_round_trip_and_projects_write_preserves_them() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        let notes = vec![Note {
+            title: "n".to_string(),
+            body: "# hi".to_string(),
+            created_at: Some(1_700_000_000),
+            updated_at: None,
+        }];
+        Json::write_notes(&notes).unwrap();
+        assert_eq!(Json::read_notes(), notes);
+
+        // A projects write (the common mutation path) must not drop notes
+        let projects = vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("t", TASK_STATUS_DONE, TASK_PRIORITY_NONE)],
+        }];
+        Json::write(&projects).unwrap();
+        assert_eq!(Json::read().unwrap(), projects);
+        assert_eq!(Json::read_notes(), notes);
+
+        // ...and a notes write must not drop projects
+        Json::write_notes(&[]).unwrap();
+        assert_eq!(Json::read().unwrap(), projects);
+    }
+
+    #[test]
+    fn write_does_not_leave_a_temp_file_behind() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        Json::write(&[]).unwrap();
+
+        let leftovers: Vec<_> = fs::read_dir(dir.path())
+            .unwrap()
+            .map(|entry| entry.unwrap().file_name())
+            .filter(|name| name != DATA_FILE_NAME)
+            .collect();
+        assert!(leftovers.is_empty(), "leftover files: {leftovers:?}");
+    }
+
+    #[test]
+    fn get_dir_path_honors_the_env_var() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+
+        assert_eq!(Json::get_dir_path(), dir.path());
+    }
+
+    #[test]
+    fn get_dir_path_falls_back_to_the_config_dir() {
+        // Must not run in parallel with tests that set BASILK_CONFIG_DIR
+        let _guard = ENV_LOCK.lock().unwrap();
+        std::env::remove_var("BASILK_CONFIG_DIR");
+
+        let path = Json::get_dir_path();
+
+        assert!(path.ends_with(env!("CARGO_PKG_NAME")));
+    }
+
+    #[test]
+    fn check_returns_false_when_the_data_file_is_already_current() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap(); // creates the file at the current version
+
+        // Second run reads the existing (current) file: no migrations
+        let migrated = Json::check().unwrap();
+
+        assert!(!migrated);
+    }
+
+    #[test]
+    fn check_migrates_old_versioned_files() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+
+        // Old format: a bare Vec<Project> stored in `<version>.json`
+        let old_projects = vec![Project {
+            title: "legacy".to_string(),
+            tasks: vec![make_task("old task", TASK_STATUS_DONE, 3)],
+        }];
+        let old_path = Json::get_json_path(JSON_VERSIONS[0].to_string());
+        fs::write(&old_path, to_string(&old_projects).unwrap()).unwrap();
+
+        let migrated = Json::check().unwrap();
+
+        assert!(migrated);
+        assert!(!old_path.is_file(), "old versioned file is removed");
+
+        let projects = Json::read().unwrap();
+        assert_eq!(projects.len(), 1);
+        assert_eq!(projects[0].title, "legacy");
+        // Migrations reset priority to NONE and clear the note
+        assert_eq!(projects[0].tasks[0].priority, TASK_PRIORITY_NONE);
+        assert_eq!(projects[0].tasks[0].note, "");
+    }
+
+    #[test]
+    fn failed_legacy_migration_keeps_the_old_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+
+        let old_path = Json::get_json_path(JSON_VERSIONS[0].to_string());
+        fs::write(&old_path, to_string(&Vec::<Project>::new()).unwrap()).unwrap();
+
+        // A directory where the data file should be makes the rename fail,
+        // so the migration errors out before touching the legacy file.
+        fs::create_dir(Json::get_data_path()).unwrap();
+
+        assert!(Json::check().is_err());
+        assert!(
+            old_path.is_file(),
+            "legacy file survives a failed migration"
+        );
+    }
+
+    #[test]
+    fn read_errors_on_a_corrupt_data_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        fs::write(Json::get_data_path(), "{ not json").unwrap();
+
+        assert!(Json::read().is_err());
+    }
+
+    #[test]
+    fn write_refuses_to_overwrite_a_corrupt_data_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        let corrupt = "{ not json";
+        fs::write(Json::get_data_path(), corrupt).unwrap();
+
+        assert!(Json::write(&[]).is_err());
+        assert!(Json::write_notes(&[]).is_err());
+        assert_eq!(
+            fs::read_to_string(Json::get_data_path()).unwrap(),
+            corrupt,
+            "the corrupt file is left untouched"
+        );
+    }
+
+    #[test]
+    fn read_notes_returns_empty_for_a_missing_file() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+
+        assert_eq!(Json::read_notes(), vec![]);
+    }
+
+    #[test]
+    fn writes_seed_a_missing_file_at_the_latest_version() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        let last_version = *JSON_VERSIONS.last().unwrap();
+
+        Json::write(&[]).unwrap();
+        let wrapper: DataWrapper =
+            from_str(&fs::read_to_string(Json::get_data_path()).unwrap()).unwrap();
+        assert_eq!(wrapper.version, last_version);
+
+        fs::remove_file(Json::get_data_path()).unwrap();
+        Json::write_notes(&[]).unwrap();
+        let wrapper: DataWrapper =
+            from_str(&fs::read_to_string(Json::get_data_path()).unwrap()).unwrap();
+        assert_eq!(wrapper.version, last_version);
+    }
+
+    #[test]
+    fn write_preserves_an_unknown_newer_version() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let dir = tempfile::tempdir().unwrap();
+        std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+        Json::check().unwrap();
+
+        // Simulate a file written by a newer binary: the version must not
+        // be downgraded by a write.
+        fs::write(
+            Json::get_data_path(),
+            to_string(&DataWrapper {
+                version: "zzz99".to_string(),
+                data: vec![],
+                notes: vec![],
+            })
+            .unwrap(),
+        )
+        .unwrap();
+
+        Json::write(&[]).unwrap();
 
-        fs::write(path, to_string(&projects).unwrap()).unwrap();
+        let wrapper: DataWrapper =
+            from_str(&fs::read_to_string(Json::get_data_path()).unwrap()).unwrap();
+        assert_eq!(wrapper.version, "zzz99");
     }
 }
diff --git a/src/main.rs b/src/main.rs
index 26f79ff..4a80293 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,67 +1,63 @@
 use std::{
+    env,
     error::Error,
-    fmt::Debug,
     io::{self, stdout},
+    process::exit,
+    time::Duration,
 };
 
-use cli::Cli;
+use cli::{Cli, CliAction};
 use ratatui::{
     crossterm::{
-        event::{self, Event, KeyCode, KeyEventKind},
+        event::{self, Event, KeyEvent},
         terminal::{disable_raw_mode, enable_raw_mode, EnterAlternateScreen, LeaveAlternateScreen},
         ExecutableCommand,
     },
     prelude::*,
-    widgets::*,
 };
-use tui_input::{backend::crossterm::EventHandler, Input};
 
+mod app;
 mod cli;
-mod config;
 mod json;
+mod markdown;
 mod migration;
+mod note;
 mod project;
 mod task;
+mod timer;
 mod ui;
 mod util;
 mod view;
 
-use config::{Config, ConfigToml};
+use app::{App, KeySource};
 use json::Json;
-use project::Project;
-use task::{Task, TASK_PRIORITIES, TASK_STATUSES};
-use view::View;
 
-#[derive(Default, PartialEq, Debug)]
-pub enum ViewMode {
-    #[default]
-    ViewProjects,
-    RenameProject,
-    AddProject,
-    DeleteProject,
+/// Reads one key event from the terminal, blocking up to 250 ms so the
+/// timer can tick between key presses; `None` on timeout. Touches the real
+/// terminal, so it is excluded from coverage (tests use `QueuedKeys`).
+pub(crate) struct CrosstermSource;
 
-    ViewTasks,
-    RenameTask,
-    ChangeStatusTask,
-    ChangePriorityTask,
-    AddTask,
-    DeleteTask,
-
-    InfoMigration,
-}
-
-pub struct App {
-    // TODO: Better list state mgmt
-    selected_project_index: ListState,
-    selected_task_index: ListState,
-    selected_status_task_index: ListState,
-    selected_priority_task_index: ListState,
-    view_mode: ViewMode,
-    projects: Vec<Project>,
-    config: ConfigToml,
+impl KeySource for CrosstermSource {
+    fn next_key(&mut self) -> io::Result<Option<KeyEvent>> {
+        if event::poll(Duration::from_millis(250))? {
+            if let Event::Key(key) = event::read()? {
+                return Ok(Some(key));
+            }
+        }
+        Ok(None)
+    }
 }
 
 fn init_terminal() -> Result<Terminal<impl Backend>, Box<dyn Error>> {
+    // Restore the terminal even if the app panics later: without this a
+    // panic leaves the terminal in raw mode / alternate screen, which
+    // looks like "the terminal can no longer accept input".
+    let default_hook = std::panic::take_hook();
+    std::panic::set_hook(Box::new(move |panic_info| {
+        let _ = restore_terminal();
+        default_hook(panic_info);
+    }));
+
     enable_raw_mode()?;
     stdout().execute(EnterAlternateScreen)?;
     let backend = CrosstermBackend::new(stdout());
@@ -76,438 +72,43 @@ fn restore_terminal() -> Result<(), Box<dyn Error>> {
 }
 
 fn main() -> Result<(), Box<dyn Error>> {
-    Cli::read();
-
-    // setup terminal
-    let terminal = init_terminal()?;
+    match Cli::parse(env::args().skip(1)) {
+        CliAction::ShowVersion => {
+            print!(env!("CARGO_PKG_VERSION"));
+            exit(0);
+        }
+        CliAction::ShowHelp => {
+            print!("{}", cli::USAGE);
+            exit(0);
+        }
+        CliAction::Run => {}
+    }
 
     // Check the version of the json file
     let were_applied_migrations = Json::check()?;
 
+    // Load the data before touching the terminal so a corrupt data file
+    // fails with a clear message instead of panicking in raw mode.
+    let mut app = App::setup().map_err(|e| {
+        format!(
+            "failed to load data from {}: {e}",
+            Json::get_data_path().display()
+        )
+    })?;
+
+    // setup terminal
+    let terminal = init_terminal()?;
+
     // create app and run it
-    App::setup().run(terminal, were_applied_migrations)?;
+    app.run_with_source(terminal, were_applied_migrations, &mut CrosstermSource)?;
 
     restore_terminal()?;
 
     Ok(())
 }
 
-impl App {
-    fn setup() -> Self {
-        Self {
-            selected_project_index: ListState::default().with_selected(Some(0)),
-            selected_task_index: ListState::default().with_selected(Some(0)),
-            selected_status_task_index: ListState::default().with_selected(Some(0)),
-            selected_priority_task_index: ListState::default().with_selected(Some(0)),
-            view_mode: ViewMode::default(),
-            projects: Json::read(),
-            config: Config::read(),
-        }
-    }
-
-    fn run(
-        &mut self,
-        mut terminal: Terminal<impl Backend>,
-        were_applied_migrations: bool,
-    ) -> io::Result<()> {
-        let mut input = Input::default();
-
-        let mut items: Vec<ListItem> = vec![];
-        Project::load_items(self, &mut items);
-
-        let mut status_items: Vec<ListItem> = vec![];
-        Task::load_statues_items(&mut status_items);
-
-        let mut priority_items: Vec<ListItem> = vec![];
-        Task::load_priority_items(&mut priority_items);
-
-        if were_applied_migrations {
-            self.view_mode = ViewMode::InfoMigration
-        }
-
-        loop {
-            terminal.draw(|f| {
-                self.render(f, f.size(), &input, &items, &status_items, &priority_items)
-            })?;
-
-            if let Event::Key(key) = event::read()? {
-                // Capture only the "Press" event to prevent double input on Windows
-                if key.kind == KeyEventKind::Press {
-                    use KeyCode::*;
-                    match self.view_mode {
-                        ViewMode::ViewProjects => match key.code {
-                            Enter | Right | Char('l') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                Task::load_items(self, &mut items);
-                                self.selected_task_index.select(Some(0));
-
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            Char('r') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                input = input
-                                    .clone()
-                                    .with_value(Project::get_current(self).title.clone());
-
-                                App::change_view(self, ViewMode::RenameProject);
-                            }
-                            Char('n') => {
-                                input.reset();
-
-                                App::change_view(self, ViewMode::AddProject);
-                            }
-                            Char('d') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                App::change_view(self, ViewMode::DeleteProject);
-                            }
-                            Down | Tab | Char('j') => {
-                                self.next(&items);
-                            }
-                            Up | BackTab | Char('k') => {
-                                self.previous(&items);
-                            }
-                            Char('q') => {
-                                return Ok(());
-                            }
-                            _ => {}
-                        },
-                        ViewMode::RenameProject => match key.code {
-                            Enter => {
-                                Project::rename(self, &mut items, input.value());
-                                input.reset();
-
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            Esc => {
-                                input.reset();
-
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            _ => {
-                                input.handle_event(&Event::Key(key));
-                            }
-                        },
-                        ViewMode::AddProject => match key.code {
-                            Esc => {
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            Enter => {
-                                Project::create(self, &mut items, input.value());
-                                self.selected_project_index
-                                    .select(Some(self.projects.len()));
-
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            _ => {
-                                input.handle_event(&Event::Key(key));
-                            }
-                        },
-                        ViewMode::DeleteProject => match key.code {
-                            Char('y') => {
-                                Project::delete(self, &mut items);
-                                self.selected_project_index.select_previous();
-
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            Char('n') => {
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            _ => {}
-                        },
-
-                        ViewMode::ViewTasks => match key.code {
-                            Esc | Left | Char('h') => {
-                                Project::load_items(self, &mut items);
-
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                            Enter => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                let index = TASK_STATUSES
-                                    .into_iter()
-                                    .position(|t| t == &Task::get_current(self).status)
-                                    .unwrap();
-
-                                self.selected_status_task_index.select(Some(index));
-
-                                App::change_view(self, ViewMode::ChangeStatusTask);
-                            }
-                            Char('p') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                let index = TASK_PRIORITIES
-                                    .into_iter()
-                                    .position(|t| t == Task::get_current(self).priority)
-                                    .unwrap();
-
-                                self.selected_priority_task_index.select(Some(index));
-
-                                App::change_view(self, ViewMode::ChangePriorityTask);
-                            }
-                            Char('r') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                input = input
-                                    .clone()
-                                    .with_value(Task::get_current(self).title.clone());
+#[cfg(test)]
+mod property_tests;
 
-                                App::change_view(self, ViewMode::RenameTask);
-                            }
-                            Char('n') => {
-                                input.reset();
-
-                                App::change_view(self, ViewMode::AddTask);
-                            }
-                            Char('d') => {
-                                if items.is_empty() {
-                                    continue;
-                                }
-
-                                App::change_view(self, ViewMode::DeleteTask);
-                            }
-                            Down | Tab | Char('j') => {
-                                self.next(&items);
-                            }
-                            Up | BackTab | Char('k') => {
-                                self.previous(&items);
-                            }
-                            Char('q') => {
-                                return Ok(());
-                            }
-                            _ => {}
-                        },
-                        ViewMode::RenameTask => match key.code {
-                            Enter => {
-                                Task::rename(self, &mut items, input.value());
-                                input.reset();
-
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            Esc => {
-                                input.reset();
-
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            _ => {
-                                input.handle_event(&Event::Key(key));
-                            }
-                        },
-                        ViewMode::ChangeStatusTask => match key.code {
-                            Enter => {
-                                Task::change_status(
-                                    self,
-                                    &mut items,
-                                    TASK_STATUSES
-                                        [self.selected_status_task_index.selected().unwrap()],
-                                );
-
-                                self.selected_status_task_index.select(Some(0));
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-
-                            Down | BackTab | Char('j') => {
-                                self.next(&status_items);
-                            }
-                            Up | Tab | Char('k') => {
-                                self.previous(&status_items);
-                            }
-                            Esc => {
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            _ => {}
-                        },
-                        ViewMode::ChangePriorityTask => match key.code {
-                            Enter => {
-                                Task::change_priority(
-                                    self,
-                                    &mut items,
-                                    TASK_PRIORITIES
-                                        [self.selected_priority_task_index.selected().unwrap()],
-                                );
-
-                                self.selected_priority_task_index.select(Some(0));
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            Down | BackTab | Char('j') => {
-                                self.next(&priority_items);
-                            }
-                            Up | Tab | Char('k') => {
-                                self.previous(&priority_items);
-                            }
-                            Esc => {
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            _ => {}
-                        },
-                        ViewMode::AddTask => match key.code {
-                            Enter => {
-                                Task::create(self, &mut items, input.value());
-
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            Esc => {
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            _ => {
-                                input.handle_event(&Event::Key(key));
-                            }
-                        },
-                        ViewMode::DeleteTask => match key.code {
-                            Char('y') => {
-                                Task::delete(self, &mut items);
-                                self.selected_task_index.select_previous();
-
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            Char('n') => {
-                                App::change_view(self, ViewMode::ViewTasks);
-                            }
-                            _ => {}
-                        },
-
-                        ViewMode::InfoMigration => match key.code {
-                            _ => {
-                                App::change_view(self, ViewMode::ViewProjects);
-                            }
-                        },
-                    }
-                }
-            }
-        }
-    }
-
-    fn render(
-        &mut self,
-        f: &mut Frame,
-        area: Rect,
-        input: &Input,
-        items: &Vec<ListItem>,
-        status_items: &Vec<ListItem>,
-        priority_items: &Vec<ListItem>,
-    ) {
-        let layout = Layout::vertical(if self.config.ui.show_help {
-            [
-                Constraint::Percentage(2),
-                Constraint::Percentage(93),
-                // Space for the footer helper
-                Constraint::Percentage(5),
-            ]
-        } else {
-            [
-                Constraint::Percentage(2),
-                // Expand the main area
-                Constraint::Percentage(98),
-                // Remove the footer help area
-                Constraint::Percentage(0),
-            ]
-        });
-
-        let [header_area, main_area, footer_area] = layout.areas(area);
-
-        // Header
-        f.render_widget(
-            Paragraph::new(format!("::{}::", env!("CARGO_PKG_NAME"))).centered(),
-            header_area,
-        );
-
-        // Main view
-        View::show_items(self, items, f, main_area);
-
-        // Other views
-        if self.view_mode == ViewMode::InfoMigration {
-            View::show_migration_info_modal(f, area);
-        }
-
-        if self.view_mode == ViewMode::AddTask || self.view_mode == ViewMode::AddProject {
-            View::show_new_item_modal(f, area, input)
-        }
-
-        if self.view_mode == ViewMode::RenameTask || self.view_mode == ViewMode::RenameProject {
-            View::show_rename_item_modal(f, area, input)
-        }
-
-        if self.view_mode == ViewMode::DeleteTask || self.view_mode == ViewMode::DeleteProject {
-            View::show_delete_item_modal(self, f, area)
-        }
-
-        if self.view_mode == ViewMode::ChangeStatusTask {
-            View::show_select_task_status_modal(self, status_items, f, area)
-        }
-
-        if self.view_mode == ViewMode::ChangePriorityTask {
-            View::show_select_task_priority_modal(self, priority_items, f, area)
-        }
-
-        if self.config.ui.show_help {
-            View::show_footer_helper(self, f, footer_area)
-        }
-    }
-
-    fn next(&mut self, items: &Vec<ListItem>) -> () {
-        let i = match self.use_state().selected() {
-            Some(i) => {
-                if i >= items.len() - 1 {
-                    0
-                } else {
-                    i + 1
-                }
-            }
-            None => 0,
-        };
-
-        self.use_state().select(Some(i))
-    }
-
-    fn previous(&mut self, items: &Vec<ListItem>) {
-        let i = match self.use_state().selected() {
-            Some(i) => {
-                if i == 0 {
-                    items.len() - 1
-                } else {
-                    i - 1
-                }
-            }
-            None => 0,
-        };
-
-        self.use_state().select(Some(i))
-    }
-
-    fn use_state(&mut self) -> &mut ListState {
-        match self.view_mode {
-            ViewMode::ViewProjects => return &mut self.selected_project_index,
-            ViewMode::RenameProject => return &mut self.selected_project_index,
-            ViewMode::AddProject => return &mut self.selected_project_index,
-            ViewMode::DeleteProject => return &mut self.selected_project_index,
-
-            ViewMode::ViewTasks => return &mut self.selected_task_index,
-            ViewMode::RenameTask => return &mut self.selected_task_index,
-            ViewMode::ChangeStatusTask => return &mut self.selected_status_task_index,
-            ViewMode::ChangePriorityTask => return &mut self.selected_priority_task_index,
-            ViewMode::AddTask => return &mut self.selected_task_index,
-            ViewMode::DeleteTask => return &mut self.selected_task_index,
-
-            ViewMode::InfoMigration => return &mut self.selected_project_index,
-        };
-    }
-
-    fn change_view(&mut self, mode: ViewMode) {
-        self.view_mode = mode
-    }
-}
+#[cfg(test)]
+pub(crate) mod test_utils;
diff --git a/src/markdown.rs b/src/markdown.rs
new file mode 100644
index 0000000..4f2ae52
--- /dev/null
+++ b/src/markdown.rs
@@ -0,0 +1,407 @@
+use pulldown_cmark::{Event, HeadingLevel, Options, Parser, Tag, TagEnd};
+use ratatui::{
+    style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
+};
+
+/// Render Markdown source into a ratatui `Text` with terminal styles.
+/// Supported: headings, bold/italic/strikethrough, inline code, code
+/// blocks, lists (bullets and numbers, nested), blockquotes, links and
+/// horizontal rules. Tables are not parsed (the pulldown-cmark tables
+/// extension is off), so their source renders as plain text; raw HTML
+/// is dropped entirely.
+pub fn render_markdown(md: &str) -> Text<'static> {
+    let mut options = Options::empty();
+    options.insert(Options::ENABLE_STRIKETHROUGH);
+    let parser = Parser::new_ext(md, options);
+
+    let mut renderer = Renderer::default();
+    renderer.run(parser);
+    Text::from(renderer.finish())
+}
+
+#[derive(Default)]
+struct Renderer {
+    lines: Vec<Line<'static>>,
+    spans: Vec<Span<'static>>,
+    style: Style,
+    style_stack: Vec<Style>,
+    /// `Some(n)` = ordered list with next number `n`, `None` = bullets.
+    list_stack: Vec<Option<u64>>,
+    quote_depth: usize,
+    in_code_block: bool,
+    link_url: Option<String>,
+}
+
+impl Renderer {
+    fn run(&mut self, parser: Parser) {
+        for event in parser {
+            match event {
+                Event::Start(tag) => self.start_tag(tag),
+                Event::End(tag) => self.end_tag(tag),
+                Event::Text(text) => self.text(&text),
+                Event::Code(code) => {
+                    self.spans.push(Span::styled(
+                        format!("`{}`", code),
+                        self.style.fg(Color::LightYellow),
+                    ));
+                }
+                Event::SoftBreak => self.spans.push(Span::raw(" ")),
+                Event::HardBreak => self.flush_line(),
+                Event::Rule => {
+                    self.blank_line_before();
+                    self.flush_line();
+                    self.lines.push(Line::from(Span::styled(
+                        "─".repeat(40),
+                        Style::default().fg(Color::DarkGray),
+                    )));
+                }
+                // Raw HTML and everything else: ignored
+                _ => {}
+            }
+        }
+    }
+
+    fn start_tag(&mut self, tag: Tag) {
+        match tag {
+            Tag::Paragraph => {
+                if self.list_stack.is_empty() {
+                    self.blank_line_before();
+                }
+            }
+            Tag::Heading { level, .. } => {
+                self.blank_line_before();
+                self.push_style(heading_style(level));
+            }
+            Tag::BlockQuote(_) => {
+                self.blank_line_before();
+                self.quote_depth += 1;
+            }
+            Tag::CodeBlock(_) => {
+                self.blank_line_before();
+                self.flush_line();
+                self.in_code_block = true;
+            }
+            Tag::List(start) => {
+                if self.list_stack.is_empty() {
+                    self.blank_line_before();
+                }
+                self.list_stack.push(start);
+            }
+            Tag::Item => {
+                self.flush_line();
+
+                let indent = "  ".repeat(self.list_stack.len().saturating_sub(1));
+                let marker = match self.list_stack.last_mut() {
+                    Some(Some(n)) => {
+                        let m = format!("{}. ", n);
+                        *n += 1;
+                        m
+                    }
+                    _ => "• ".to_string(),
+                };
+                self.spans
+                    .push(Span::styled(format!("{}{}", indent, marker), self.style));
+            }
+            Tag::Strong => self.push_style(self.style.add_modifier(Modifier::BOLD)),
+            Tag::Emphasis => self.push_style(self.style.add_modifier(Modifier::ITALIC)),
+            Tag::Strikethrough => self.push_style(self.style.add_modifier(Modifier::CROSSED_OUT)),
+            Tag::Link { dest_url, .. } => {
+                self.link_url = Some(dest_url.to_string());
+                self.push_style(
+                    self.style
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::UNDERLINED),
+                );
+            }
+            _ => {}
+        }
+    }
+
+    fn end_tag(&mut self, tag: TagEnd) {
+        match tag {
+            TagEnd::Paragraph => self.flush_line(),
+            TagEnd::Heading(_) => {
+                self.flush_line();
+                self.pop_style();
+            }
+            TagEnd::BlockQuote(_) => {
+                self.flush_line();
+                self.quote_depth = self.quote_depth.saturating_sub(1);
+            }
+            TagEnd::CodeBlock => {
+                self.in_code_block = false;
+            }
+            TagEnd::List(_) => {
+                self.list_stack.pop();
+            }
+            TagEnd::Item => self.flush_line(),
+            TagEnd::Strong | TagEnd::Emphasis | TagEnd::Strikethrough => self.pop_style(),
+            TagEnd::Link => {
+                self.pop_style();
+                if let Some(url) = self.link_url.take() {
+                    self.spans.push(Span::styled(
+                        format!(" ({})", url),
+                        Style::default().fg(Color::DarkGray),
+                    ));
+                }
+            }
+            _ => {}
+        }
+    }
+
+    fn text(&mut self, text: &str) {
+        if self.in_code_block {
+            // Code block content arrives as one chunk; emit it line by line
+            for line in text.lines() {
+                self.lines.push(Line::from(Span::styled(
+                    format!("  {}", line),
+                    Style::default().fg(Color::LightYellow),
+                )));
+            }
+            return;
+        }
+
+        self.spans.push(Span::styled(text.to_string(), self.style));
+    }
+
+    fn push_style(&mut self, style: Style) {
+        self.style_stack.push(self.style);
+        self.style = style;
+    }
+
+    fn pop_style(&mut self) {
+        self.style = self.style_stack.pop().unwrap_or_default();
+    }
+
+    /// Push a separating blank line when the previous line has content.
+    fn blank_line_before(&mut self) {
+        let has_content = self
+            .lines
+            .last()
+            .is_some_and(|l| l.spans.iter().any(|s| !s.content.trim().is_empty()));
+
+        if has_content || !self.spans.is_empty() {
+            self.flush_line();
+            self.lines.push(Line::default());
+        }
+    }
+
+    fn flush_line(&mut self) {
+        if self.spans.is_empty() {
+            return;
+        }
+
+        let mut spans = std::mem::take(&mut self.spans);
+        if self.quote_depth > 0 {
+            let mut quoted = Vec::with_capacity(spans.len() + 1);
+            quoted.push(Span::styled(
+                "│ ".repeat(self.quote_depth),
+                Style::default().fg(Color::DarkGray),
+            ));
+            quoted.append(&mut spans);
+            self.lines.push(Line::from(quoted));
+        } else {
+            self.lines.push(Line::from(spans));
+        }
+    }
+
+    fn finish(mut self) -> Vec<Line<'static>> {
+        self.flush_line();
+
+        while self
+            .lines
+            .last()
+            .is_some_and(|l| !l.spans.iter().any(|s| !s.content.trim().is_empty()))
+        {
+            self.lines.pop();
+        }
+
+        self.lines
+    }
+}
+
+fn heading_style(level: HeadingLevel) -> Style {
+    match level {
+        HeadingLevel::H1 => Style::default()
+            .fg(Color::Cyan)
+            .add_modifier(Modifier::BOLD | Modifier::UNDERLINED),
+        HeadingLevel::H2 => Style::default()
+            .fg(Color::Green)
+            .add_modifier(Modifier::BOLD),
+        HeadingLevel::H3 => Style::default()
+            .fg(Color::LightMagenta)
+            .add_modifier(Modifier::BOLD),
+        _ => Style::default().add_modifier(Modifier::BOLD),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn line_text(line: &Line) -> String {
+        line.spans.iter().map(|s| s.content.as_ref()).collect()
+    }
+
+    fn rendered_lines(md: &str) -> Vec<String> {
+        render_markdown(md).lines.iter().map(line_text).collect()
+    }
+
+    #[test]
+    fn empty_input_produces_no_lines() {
+        assert!(render_markdown("").lines.is_empty());
+        assert!(render_markdown("  \n\n ").lines.is_empty());
+    }
+
+    #[test]
+    fn heading_is_styled_by_level() {
+        let text = render_markdown("# Title\n\n## Sub\n\n#### Deep");
+        assert_eq!(line_text(&text.lines[0]), "Title");
+        assert!(text.lines[0].spans[0]
+            .style
+            .add_modifier
+            .contains(Modifier::BOLD | Modifier::UNDERLINED));
+        assert_eq!(text.lines[0].spans[0].style.fg, Some(Color::Cyan));
+
+        assert_eq!(line_text(&text.lines[2]), "Sub");
+        assert_eq!(text.lines[2].spans[0].style.fg, Some(Color::Green));
+
+        assert_eq!(line_text(&text.lines[4]), "Deep");
+        assert_eq!(text.lines[4].spans[0].style.fg, None);
+    }
+
+    #[test]
+    fn inline_styles_apply_modifiers() {
+        let text = render_markdown("a **b** *c* ~~d~~ `e`");
+        let spans = &text.lines[0].spans;
+
+        let bold = spans.iter().find(|s| s.content == "b").unwrap();
+        assert!(bold.style.add_modifier.contains(Modifier::BOLD));
+
+        let italic = spans.iter().find(|s| s.content == "c").unwrap();
+        assert!(italic.style.add_modifier.contains(Modifier::ITALIC));
+
+        let struck = spans.iter().find(|s| s.content == "d").unwrap();
+        assert!(struck.style.add_modifier.contains(Modifier::CROSSED_OUT));
+
+        let code = spans.iter().find(|s| s.content == "`e`").unwrap();
+        assert_eq!(code.style.fg, Some(Color::LightYellow));
+
+        // Styles do not leak into the surrounding text
+        let plain = spans.iter().find(|s| s.content.contains('a')).unwrap();
+        assert_eq!(plain.style.add_modifier, Modifier::empty());
+    }
+
+    #[test]
+    fn nested_bold_italic_keeps_both_modifiers() {
+        let text = render_markdown("***both***");
+        let span = &text.lines[0].spans[0];
+        assert!(span.style.add_modifier.contains(Modifier::BOLD));
+        assert!(span.style.add_modifier.contains(Modifier::ITALIC));
+    }
+
+    #[test]
+    fn unordered_list_uses_bullets() {
+        let lines = rendered_lines("- one\n- two");
+        assert_eq!(lines, vec!["• one", "• two"]);
+    }
+
+    #[test]
+    fn ordered_list_numbers_sequentially() {
+        let lines = rendered_lines("1. one\n2. two\n3. three");
+        assert_eq!(lines, vec!["1. one", "2. two", "3. three"]);
+    }
+
+    #[test]
+    fn nested_list_is_indented() {
+        let lines = rendered_lines("- outer\n  - inner");
+        assert_eq!(lines, vec!["• outer", "  • inner"]);
+    }
+
+    #[test]
+    fn code_block_lines_are_indented_and_styled() {
+        let text = render_markdown("before\n\n```rust\nlet a = 1;\nlet b = 2;\n```\n\nafter");
+        let lines: Vec<String> = text.lines.iter().map(line_text).collect();
+
+        assert_eq!(
+            lines,
+            vec!["before", "", "  let a = 1;", "  let b = 2;", "", "after"]
+        );
+        assert_eq!(text.lines[2].spans[0].style.fg, Some(Color::LightYellow));
+    }
+
+    #[test]
+    fn blockquote_gets_bar_prefix() {
+        let text = render_markdown("> quoted");
+        assert_eq!(line_text(&text.lines[0]), "│ quoted");
+        assert_eq!(text.lines[0].spans[0].style.fg, Some(Color::DarkGray));
+    }
+
+    #[test]
+    fn link_is_underlined_with_dim_url() {
+        let text = render_markdown("[click](https://example.com)");
+        let spans = &text.lines[0].spans;
+
+        assert!(spans[0].style.add_modifier.contains(Modifier::UNDERLINED));
+        assert_eq!(spans[0].content.as_ref(), "click");
+        assert_eq!(spans[1].content.as_ref(), " (https://example.com)");
+        assert_eq!(spans[1].style.fg, Some(Color::DarkGray));
+    }
+
+    #[test]
+    fn rule_renders_a_dim_bar() {
+        let lines = rendered_lines("a\n\n---\n\nb");
+        assert_eq!(lines, vec!["a", "", "─".repeat(40).as_str(), "", "b"]);
+    }
+
+    #[test]
+    fn paragraphs_are_separated_by_a_blank_line() {
+        let lines = rendered_lines("first\n\nsecond");
+        assert_eq!(lines, vec!["first", "", "second"]);
+    }
+
+    #[test]
+    fn soft_breaks_join_into_one_line() {
+        let lines = rendered_lines("foo\nbar");
+        assert_eq!(lines, vec!["foo bar"]);
+    }
+
+    #[test]
+    fn raw_html_is_ignored() {
+        assert!(render_markdown("<div>ignored</div>").lines.is_empty());
+    }
+
+    #[test]
+    fn image_alt_text_is_kept_but_the_url_is_not_shown() {
+        let lines = rendered_lines("![alt](https://example.com/pic.png)");
+        assert_eq!(lines, vec!["alt"]);
+    }
+
+    #[test]
+    fn h3_heading_gets_the_magenta_style() {
+        let text = render_markdown("### three");
+        assert_eq!(line_text(&text.lines[0]), "three");
+        assert_eq!(text.lines[0].spans[0].style.fg, Some(Color::LightMagenta));
+    }
+
+    #[test]
+    fn hard_breaks_split_the_line() {
+        let lines = rendered_lines("foo  \nbar");
+        assert_eq!(lines, vec!["foo", "bar"]);
+    }
+
+    #[test]
+    fn trailing_blank_lines_are_trimmed() {
+        // The empty heading produces a trailing blank line that `finish` trims
+        let lines = rendered_lines("# hi\n\n# ");
+        assert_eq!(lines, vec!["hi"]);
+    }
+
+    #[test]
+    fn unclosed_and_malformed_input_does_not_panic() {
+        for md in ["**", "# ", "```\nunclosed", "[](", "> ", "-", "1.", "│ │"] {
+            render_markdown(md);
+        }
+    }
+}
diff --git a/src/migration.rs b/src/migration.rs
index 4a83687..2b2dd9f 100644
--- a/src/migration.rs
+++ b/src/migration.rs
@@ -1,71 +1,136 @@
-use serde_json::{
-    json, to_string, Map,
-    Value::{self},
-};
+use crate::project::Project;
+use crate::task::TASK_PRIORITY_NONE;
 
-//                              sha of 0.1.0     0.2.0
-pub static JSON_VERSIONS: [&str; 2] = ["6ad96", "911fc"];
+//                              sha of 0.1.0     0.2.0    0.2.2     timer     notes
+pub static JSON_VERSIONS: [&str; 5] = ["6ad96", "911fc", "a4e1b", "c8f21", "e5a1c"];
+
+type MigrationFn = fn(Vec<Project>) -> Vec<Project>;
 
 pub struct Migration;
 
 impl Migration {
-    pub fn get_migrations(version: &str, original_json: Vec<Value>) -> Vec<(&str, String)> {
+    pub fn get_migrations(version: &str, original_json: Vec<Project>) -> Vec<(&str, Vec<Project>)> {
         // Mapper between json version and the relative migration
-        let mapper: Vec<(&str, String)> = vec![
-            ("6ad96", "".to_string()),
-            ("911fc", Migration::add_priority(original_json)),
+        let mapper: Vec<(&str, MigrationFn)> = vec![
+            ("6ad96", |data| data),
+            ("911fc", Migration::add_priority),
+            ("a4e1b", Migration::add_note),
+            ("c8f21", Migration::add_timer_fields),
+            // Notes live outside `Vec<Project>` and default to empty via
+            // serde, so this step only bumps the stored version
+            ("e5a1c", |data| data),
         ];
 
         // The start index where the migration are picked
-        let start_index = mapper
-            .clone()
-            .into_iter()
-            .position(|(key, _val)| key == version);
+        let start_index = mapper.iter().position(|(key, _val)| *key == version);
 
         if start_index.is_none() {
             return vec![];
         }
 
-        let all_migrations: Vec<(&str, String)> = mapper.into_iter().collect();
+        let mut results = vec![];
+        let mut current_data = original_json;
+
+        for (v, migration_fn) in mapper.into_iter().skip(start_index.unwrap() + 1) {
+            current_data = migration_fn(current_data);
+            results.push((v, current_data.clone()));
+        }
 
-        // Slice for pick only the useful migration
-        return all_migrations[(start_index.unwrap() + 1)..].to_vec();
+        results
     }
 
     // Migrations
-    fn add_priority(original_json: Vec<Value>) -> String {
-        let mut internal_json = original_json.clone();
-
-        let new_json: Vec<Map<String, Value>> = internal_json
-            .iter_mut()
-            .map(|p| {
-                // Get all tasks from each project and convert into "Map" type from serde
-                // in order to do some operations with the json
-                // Vec = Array ; Map = Object
-                let mut tasks = serde_json::from_value::<Vec<Map<String, Value>>>(
-                    p.get("tasks").unwrap().clone(),
-                )
-                .unwrap();
-
-                // Add to each task a new key value (i.e. {priority: 0})
-                tasks.iter_mut().for_each(|t| {
-                    // Entry and or_insert methods are used for add a new key
-                    // cf. https://docs.rs/serde_json/latest/serde_json/map/enum.Entry.html#method.or_insert
-                    t.entry("priority").or_insert(json!(0));
-                });
-
-                // Convert "p" into the "Map" type from serde in order to do some operations with the json
-                let mut project = serde_json::from_value::<Map<String, Value>>(p.clone()).unwrap();
-
-                // Replace the "tasks" key with the new one
-                // Insert method is used for replace a new with a new value
-                // cf. https://docs.rs/serde_json/latest/serde_json/map/struct.Map.html#method.insert
-                project.insert("tasks".to_string(), json!(tasks)).unwrap();
-
-                return project;
-            })
-            .collect();
-
-        return to_string(&new_json).unwrap();
+    fn add_priority(mut data: Vec<Project>) -> Vec<Project> {
+        for p in data.iter_mut() {
+            for t in p.tasks.iter_mut() {
+                t.priority = TASK_PRIORITY_NONE;
+            }
+        }
+        data
+    }
+
+    fn add_note(mut data: Vec<Project>) -> Vec<Project> {
+        for p in data.iter_mut() {
+            for t in p.tasks.iter_mut() {
+                t.note = "".to_string();
+            }
+        }
+        data
+    }
+
+    fn add_timer_fields(mut data: Vec<Project>) -> Vec<Project> {
+        for p in data.iter_mut() {
+            for t in p.tasks.iter_mut() {
+                t.time_spent_secs = 0;
+                t.estimated_hours = 0;
+            }
+        }
+        data
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::task::{Task, TASK_PRIORITY_NONE, TASK_STATUS_ON_GOING};
+
+    fn sample_data() -> Vec<Project> {
+        vec![Project {
+            title: "p".to_string(),
+            tasks: vec![Task {
+                title: "t".to_string(),
+                status: TASK_STATUS_ON_GOING.to_string(),
+                priority: 2,
+                created_at: None,
+                completed_at: None,
+                note: "keep me".to_string(),
+                time_spent_secs: 42,
+                estimated_hours: 7,
+            }],
+        }]
+    }
+
+    #[test]
+    fn migrations_from_oldest_version_apply_all_steps() {
+        let migrations = Migration::get_migrations("6ad96", sample_data());
+
+        assert_eq!(migrations.len(), 4);
+        assert_eq!(migrations[0].0, "911fc");
+        assert_eq!(migrations[1].0, "a4e1b");
+        assert_eq!(migrations[2].0, "c8f21");
+        assert_eq!(migrations[3].0, "e5a1c");
+
+        let task = &migrations[3].1[0].tasks[0];
+        assert_eq!(task.priority, TASK_PRIORITY_NONE);
+        assert_eq!(task.note, "");
+        assert_eq!(task.time_spent_secs, 0);
+        assert_eq!(task.estimated_hours, 0);
+    }
+
+    #[test]
+    fn migrations_from_middle_version_apply_remaining_steps() {
+        let migrations = Migration::get_migrations("911fc", sample_data());
+
+        assert_eq!(migrations.len(), 3);
+        assert_eq!(migrations[0].0, "a4e1b");
+        assert_eq!(migrations[1].0, "c8f21");
+        assert_eq!(migrations[2].0, "e5a1c");
+        // add_priority is not re-applied: priority is preserved
+        assert_eq!(migrations[0].1[0].tasks[0].priority, 2);
+    }
+
+    #[test]
+    fn no_migrations_for_latest_or_unknown_version() {
+        assert!(Migration::get_migrations("e5a1c", sample_data()).is_empty());
+        assert!(Migration::get_migrations("unknown", sample_data()).is_empty());
+    }
+
+    #[test]
+    fn json_versions_are_chained_in_mapper_order() {
+        // Every version except the last must produce migrations ending at the last version
+        for (i, version) in JSON_VERSIONS.iter().enumerate() {
+            let migrations = Migration::get_migrations(version, vec![]);
+            assert_eq!(migrations.len(), JSON_VERSIONS.len() - 1 - i);
+        }
     }
 }
diff --git a/src/note.rs b/src/note.rs
new file mode 100644
index 0000000..cbd8931
--- /dev/null
+++ b/src/note.rs
@@ -0,0 +1,237 @@
+use ratatui::{
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::ListItem,
+};
+use serde::{Deserialize, Serialize};
+use std::time::{SystemTime, UNIX_EPOCH};
+
+use crate::{app::App, json::Json};
+
+/// A global, project-independent note. `body` holds Markdown source that
+/// the preview view renders via `markdown::render_markdown`.
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
+pub struct Note {
+    pub title: String,
+    pub body: String,
+    #[serde(default)]
+    pub created_at: Option<u64>,
+    #[serde(default)]
+    pub updated_at: Option<u64>,
+}
+
+impl Note {
+    fn current_timestamp() -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
+
+    pub fn load_items(app: &mut App, items: &mut Vec<ListItem>) {
+        items.clear();
+
+        for note in app.notes.iter() {
+            // First non-empty body line as a dim one-line snippet
+            let snippet: String = note
+                .body
+                .lines()
+                .find(|l| !l.trim().is_empty())
+                .unwrap_or("")
+                .chars()
+                .take(40)
+                .collect();
+
+            let mut spans = vec![Span::raw(note.title.clone())];
+            if !snippet.is_empty() {
+                spans.push(Span::styled(
+                    format!("  {}", snippet),
+                    Style::default().fg(Color::DarkGray),
+                ));
+            }
+
+            items.push(ListItem::from(Line::from(spans)))
+        }
+
+        let selected = app
+            .selected_note_index
+            .selected()
+            .unwrap_or(0)
+            .min(app.notes.len().saturating_sub(1));
+        app.selected_note_index.select(Some(selected));
+    }
+
+    pub fn get_current(app: &App) -> &Note {
+        &app.notes[app.selected_note_index.selected().unwrap()]
+    }
+
+    pub fn create(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
+        if value.is_empty() {
+            return;
+        }
+
+        app.notes.push(Note {
+            title: value.to_string(),
+            body: String::new(),
+            created_at: Some(Self::current_timestamp()),
+            updated_at: None,
+        });
+
+        Json::write_notes(&app.notes).unwrap();
+        Note::load_items(app, items)
+    }
+
+    pub fn rename(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
+        if value.is_empty() {
+            return;
+        }
+
+        let note = &mut app.notes[app.selected_note_index.selected().unwrap()];
+        note.title = value.to_string();
+        note.updated_at = Some(Self::current_timestamp());
+
+        Json::write_notes(&app.notes).unwrap();
+        Note::load_items(app, items)
+    }
+
+    pub fn update_body(app: &mut App, value: &str) {
+        let note = &mut app.notes[app.selected_note_index.selected().unwrap()];
+        note.body = value.to_string();
+        note.updated_at = Some(Self::current_timestamp());
+
+        Json::write_notes(&app.notes).unwrap();
+    }
+
+    pub fn delete(app: &mut App, items: &mut Vec<ListItem>) {
+        app.notes
+            .remove(app.selected_note_index.selected().unwrap());
+
+        Json::write_notes(&app.notes).unwrap();
+        Note::load_items(app, items)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{make_app, setup_temp_config, ENV_LOCK};
+
+    fn make_note(title: &str, body: &str) -> Note {
+        Note {
+            title: title.to_string(),
+            body: body.to_string(),
+            created_at: Some(1_700_000_000),
+            updated_at: None,
+        }
+    }
+
+    #[test]
+    fn create_appends_note_and_persists() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut items = vec![];
+
+        Note::create(&mut app, &mut items, "shopping");
+
+        assert_eq!(app.notes.len(), 1);
+        assert_eq!(app.notes[0].title, "shopping");
+        assert!(app.notes[0].created_at.is_some());
+        assert_eq!(items.len(), 1);
+        assert_eq!(Json::read_notes(), app.notes);
+    }
+
+    #[test]
+    fn create_with_empty_value_is_a_no_op() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut items = vec![];
+
+        Note::create(&mut app, &mut items, "");
+
+        assert!(app.notes.is_empty());
+    }
+
+    #[test]
+    fn rename_updates_selected_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("old", "")];
+        let mut items = vec![];
+
+        Note::rename(&mut app, &mut items, "new");
+
+        assert_eq!(app.notes[0].title, "new");
+        assert!(app.notes[0].updated_at.is_some());
+        assert_eq!(Json::read_notes()[0].title, "new");
+    }
+
+    #[test]
+    fn rename_with_empty_value_is_a_no_op() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("old", "")];
+        let mut items = vec![];
+
+        Note::rename(&mut app, &mut items, "");
+
+        assert_eq!(app.notes[0].title, "old");
+        assert_eq!(app.notes[0].updated_at, None);
+    }
+
+    #[test]
+    fn update_body_sets_body_and_updated_at() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("n", "")];
+
+        Note::update_body(&mut app, "# Hello\nworld");
+
+        assert_eq!(app.notes[0].body, "# Hello\nworld");
+        assert!(app.notes[0].updated_at.is_some());
+        assert_eq!(Json::read_notes()[0].body, "# Hello\nworld");
+    }
+
+    #[test]
+    fn delete_removes_selected_note() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("n1", ""), make_note("n2", "")];
+        app.selected_note_index.select(Some(1));
+        let mut items = vec![];
+
+        Note::delete(&mut app, &mut items);
+
+        assert_eq!(app.notes.len(), 1);
+        assert_eq!(app.notes[0].title, "n1");
+        assert_eq!(Json::read_notes().len(), 1);
+    }
+
+    #[test]
+    fn load_items_shows_first_body_line_as_snippet() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("n", "\n# Title\nsecond line")];
+        let mut items = vec![];
+
+        Note::load_items(&mut app, &mut items);
+
+        assert_eq!(items.len(), 1);
+    }
+
+    #[test]
+    fn load_items_clamps_selection_into_bounds() {
+        let mut app = make_app(vec![]);
+        app.notes = vec![make_note("only", "")];
+        app.selected_note_index.select(Some(5));
+        let mut items = vec![];
+
+        Note::load_items(&mut app, &mut items);
+
+        assert_eq!(app.selected_note_index.selected(), Some(0));
+    }
+}
diff --git a/src/project.rs b/src/project.rs
index f08c1cf..cb58ff5 100644
--- a/src/project.rs
+++ b/src/project.rs
@@ -6,12 +6,12 @@ use ratatui::{
 use serde::{Deserialize, Serialize};
 
 use crate::{
+    app::App,
     json::Json,
     task::{Task, TASK_STATUS_DONE},
-    App,
 };
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
 pub struct Project {
     pub title: String,
     pub tasks: Vec<Task>,
@@ -20,11 +20,11 @@ pub struct Project {
 impl Project {
     fn get_indicator_done_tasks_color(percentage: usize) -> ratatui::prelude::Color {
         match percentage {
-            p if p == 0 => return Color::DarkGray,
-            p if p >= 25 && p <= 50 => return Color::LightMagenta,
-            p if p >= 50 && p < 100 => return Color::LightYellow,
-            p if p == 100 => return Color::LightGreen,
-            _ => return Color::White,
+            0 => Color::DarkGray,
+            p if (1..=50).contains(&p) => Color::LightMagenta,
+            p if p > 50 && p < 100 => Color::LightYellow,
+            100 => Color::LightGreen,
+            _ => Color::White,
         }
     }
 
@@ -34,20 +34,19 @@ impl Project {
         for project in app.projects.iter() {
             let tasks = &project.tasks;
 
-            let done_tasks: Vec<Task> = tasks
-                .clone()
-                .into_iter()
+            let done_tasks = tasks
+                .iter()
                 .filter(|t| t.status == TASK_STATUS_DONE)
-                .collect();
+                .count();
 
-            let percentage = if tasks.len() == 0 {
+            let percentage = if tasks.is_empty() {
                 0
             } else {
-                (done_tasks.len() * 100) / tasks.len()
+                (done_tasks * 100) / tasks.len()
             };
 
             let lines = vec![Line::from(vec![
-                Span::raw(format!("[{}/{}] ", done_tasks.len(), tasks.len(),)).style(
+                Span::raw(format!("[{}/{}] ", done_tasks, tasks.len())).style(
                     Style::default().fg(Project::get_indicator_done_tasks_color(percentage)),
                 ),
                 Span::raw(project.title.clone()),
@@ -57,13 +56,8 @@ impl Project {
         }
     }
 
-    pub fn reload(app: &mut App, items: &mut Vec<ListItem>) {
-        app.projects = Json::read();
-        Project::load_items(app, items)
-    }
-
-    pub fn get_current(app: &mut App) -> &Project {
-        return &app.projects[app.selected_project_index.selected().unwrap()];
+    pub fn get_current(app: &App) -> &Project {
+        &app.projects[app.selected_project_index.selected().unwrap()]
     }
 
     pub fn create(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
@@ -71,33 +65,128 @@ impl Project {
             return;
         }
 
-        let new_project = Project {
+        app.projects.push(Project {
             title: value.to_string(),
             tasks: vec![],
-        };
-
-        let mut internal_projects = app.projects.clone();
-        internal_projects.push(new_project);
+        });
 
-        Json::write(internal_projects);
-        Project::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Project::load_items(app, items)
     }
 
     pub fn rename(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
-        let mut internal_projects = app.projects.clone();
-
-        internal_projects[app.selected_project_index.selected().unwrap()].title = value.to_string();
+        app.projects[app.selected_project_index.selected().unwrap()].title = value.to_string();
 
-        Json::write(internal_projects);
-        Project::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Project::load_items(app, items)
     }
 
     pub fn delete(app: &mut App, items: &mut Vec<ListItem>) {
-        let mut internal_projects = app.projects.clone();
+        app.projects
+            .remove(app.selected_project_index.selected().unwrap());
+
+        Json::write(&app.projects).unwrap();
+        Project::load_items(app, items)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::test_utils::{make_app, sample_projects, setup_temp_config, ENV_LOCK};
+
+    #[test]
+    fn create_appends_project_and_persists() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut items = vec![];
+
+        Project::create(&mut app, &mut items, "todo");
+
+        assert_eq!(app.projects.len(), 1);
+        assert_eq!(app.projects[0].title, "todo");
+        assert_eq!(items.len(), 1);
+        assert_eq!(Json::read().unwrap(), app.projects);
+    }
 
-        internal_projects.remove(app.selected_project_index.selected().unwrap());
+    #[test]
+    fn create_with_empty_value_is_a_no_op() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut items = vec![];
+
+        Project::create(&mut app, &mut items, "");
+
+        assert!(app.projects.is_empty());
+        assert!(items.is_empty());
+    }
+
+    #[test]
+    fn rename_updates_selected_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        let mut items = vec![];
+        app.selected_project_index.select(Some(1));
+
+        Project::rename(&mut app, &mut items, "renamed");
+
+        assert_eq!(app.projects[1].title, "renamed");
+        assert_eq!(app.projects[0].title, "alpha");
+        assert_eq!(Json::read().unwrap()[1].title, "renamed");
+    }
+
+    #[test]
+    fn delete_removes_selected_project() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(sample_projects());
+        let mut items = vec![];
+
+        Project::delete(&mut app, &mut items);
+
+        assert_eq!(app.projects.len(), 1);
+        assert_eq!(app.projects[0].title, "beta");
+        assert_eq!(items.len(), 1);
+        assert_eq!(Json::read().unwrap(), app.projects);
+    }
+
+    #[test]
+    fn load_items_builds_one_item_per_project() {
+        let mut app = make_app(sample_projects());
+        let mut items = vec![];
+
+        Project::load_items(&mut app, &mut items);
+
+        assert_eq!(items.len(), 2);
+    }
 
-        Json::write(internal_projects);
-        Project::reload(app, items)
+    #[test]
+    fn done_tasks_color_thresholds() {
+        assert_eq!(Project::get_indicator_done_tasks_color(0), Color::DarkGray);
+        assert_eq!(
+            Project::get_indicator_done_tasks_color(1),
+            Color::LightMagenta
+        );
+        assert_eq!(
+            Project::get_indicator_done_tasks_color(25),
+            Color::LightMagenta
+        );
+        assert_eq!(
+            Project::get_indicator_done_tasks_color(50),
+            Color::LightMagenta
+        );
+        assert_eq!(
+            Project::get_indicator_done_tasks_color(75),
+            Color::LightYellow
+        );
+        assert_eq!(
+            Project::get_indicator_done_tasks_color(100),
+            Color::LightGreen
+        );
+        // Values outside 0..=100 fall back to white
+        assert_eq!(Project::get_indicator_done_tasks_color(101), Color::White);
     }
 }
diff --git a/src/property_tests.rs b/src/property_tests.rs
new file mode 100644
index 0000000..d69969a
--- /dev/null
+++ b/src/property_tests.rs
@@ -0,0 +1,153 @@
+//! Property-based (fuzz-style) tests.
+//!
+//! These tests feed randomized inputs — including invalid statuses and
+//! priorities — into the data layer to make sure nothing panics and the
+//! documented invariants hold for any input.
+use proptest::prelude::*;
+
+use crate::migration::{Migration, JSON_VERSIONS};
+use crate::project::Project;
+use crate::task::{Task, TASK_STATUS_DONE, TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT};
+use crate::test_utils::make_app;
+use crate::util::Util;
+
+fn arb_status() -> impl Strategy<Value = String> {
+    prop::sample::select(vec![
+        TASK_STATUS_UP_NEXT.to_string(),
+        TASK_STATUS_ON_GOING.to_string(),
+        TASK_STATUS_DONE.to_string(),
+        // Unknown status values must not crash anything
+        "Bogus".to_string(),
+    ])
+}
+
+fn arb_task() -> impl Strategy<Value = Task> {
+    (
+        ".*",
+        arb_status(),
+        any::<u8>(),
+        any::<Option<u64>>(),
+        any::<Option<u64>>(),
+        ".*",
+        any::<u64>(),
+        any::<u64>(),
+    )
+        .prop_map(
+            |(
+                title,
+                status,
+                priority,
+                created_at,
+                completed_at,
+                note,
+                time_spent_secs,
+                estimated_hours,
+            )| {
+                Task {
+                    title,
+                    status,
+                    priority,
+                    created_at,
+                    completed_at,
+                    note,
+                    time_spent_secs,
+                    estimated_hours,
+                }
+            },
+        )
+}
+
+fn arb_projects() -> impl Strategy<Value = Vec<Project>> {
+    prop::collection::vec(
+        (".*", prop::collection::vec(arb_task(), 0..8))
+            .prop_map(|(title, tasks)| Project { title, tasks }),
+        0..5,
+    )
+}
+
+proptest! {
+    #[test]
+    fn serde_round_trip(projects in arb_projects()) {
+        let raw = serde_json::to_string(&projects).unwrap();
+        let parsed: Vec<Project> = serde_json::from_str(&raw).unwrap();
+        prop_assert_eq!(projects, parsed);
+    }
+
+    #[test]
+    fn migrations_never_panic_and_preserve_shape(
+        projects in arb_projects(),
+        version in prop::sample::select(JSON_VERSIONS.to_vec()),
+    ) {
+        let task_count: usize = projects.iter().map(|p| p.tasks.len()).sum();
+        let migrations = Migration::get_migrations(version, projects);
+
+        prop_assert!(migrations.len() < JSON_VERSIONS.len());
+        for (_, data) in &migrations {
+            prop_assert_eq!(
+                data.iter().map(|p| p.tasks.len()).sum::<usize>(),
+                task_count
+            );
+        }
+    }
+
+    #[test]
+    fn task_load_items_never_panics_and_selects_a_valid_index(
+        tasks in prop::collection::vec(arb_task(), 0..8),
+        hide_done in any::<bool>(),
+        board_view in any::<bool>(),
+        selected in any::<usize>(),
+    ) {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks,
+        }]);
+        app.hide_done_tasks = hide_done;
+        app.board_view = board_view;
+        app.selected_task_index.select(Some(selected));
+        let mut items = vec![];
+
+        Task::load_items(&mut app, &mut items);
+
+        // The board always shows the Done lane, ignoring `hide_done_tasks`
+        let expected_visible = app.projects[0]
+            .tasks
+            .iter()
+            .filter(|t| !(!board_view && hide_done && t.status == TASK_STATUS_DONE))
+            .count();
+        prop_assert_eq!(items.len(), expected_visible);
+        if !items.is_empty() {
+            prop_assert!(app.selected_task_index.selected().unwrap() < items.len());
+        }
+    }
+
+    #[test]
+    fn project_load_items_matches_project_count(projects in arb_projects()) {
+        let mut app = make_app(projects.clone());
+        let mut items = vec![];
+
+        Project::load_items(&mut app, &mut items);
+
+        prop_assert_eq!(items.len(), projects.len());
+    }
+
+    #[test]
+    fn format_duration_never_panics(a in any::<Option<u64>>(), b in any::<Option<u64>>()) {
+        let out = Util::format_duration(a, b);
+        prop_assert!(!out.is_empty());
+    }
+
+    #[test]
+    fn format_timestamp_never_panics(ts in any::<Option<u64>>()) {
+        let _ = Util::format_timestamp(ts);
+    }
+
+    #[test]
+    fn priority_indicator_is_bounded(value in any::<u8>()) {
+        prop_assert!(Util::get_priority_indicator(value).chars().count() <= 3);
+    }
+
+    #[test]
+    fn render_markdown_never_panics(md in ".*") {
+        let _ = crate::markdown::render_markdown(&md);
+    }
+}
diff --git a/src/task.rs b/src/task.rs
index 37bf5dd..01b67fe 100644
--- a/src/task.rs
+++ b/src/task.rs
@@ -4,47 +4,64 @@ use ratatui::{
     widgets::ListItem,
 };
 use serde::{Deserialize, Serialize};
+use std::time::{SystemTime, UNIX_EPOCH};
 
-use crate::{json::Json, util::Util, App};
+use crate::{app::App, json::Json, util::Util};
 
-#[derive(Deserialize, Serialize, Debug, Clone)]
+#[derive(Deserialize, Serialize, Debug, Clone, PartialEq)]
 pub struct Task {
     pub title: String,
     pub status: String,
     pub priority: u8,
+    #[serde(default)]
+    pub created_at: Option<u64>,
+    #[serde(default)]
+    pub completed_at: Option<u64>,
+    #[serde(default)]
+    pub note: String,
+    #[serde(default)]
+    pub time_spent_secs: u64,
+    /// Estimated time the task is expected to take; 0 = no estimate.
+    #[serde(default)]
+    pub estimated_hours: u64,
 }
 
 pub const TASK_STATUS_DONE: &str = "Done";
 pub const TASK_STATUS_ON_GOING: &str = "OnGoing";
 pub const TASK_STATUS_UP_NEXT: &str = "UpNext";
 
-pub const TASK_STATUSES: [&'static str; 3] =
-    [TASK_STATUS_UP_NEXT, TASK_STATUS_ON_GOING, TASK_STATUS_DONE];
+pub const TASK_PRIORITY_NONE: u8 = 0;
 
-const TASK_STATUSES_SORT_ORDER: [&'static str; 3] =
+pub const TASK_STATUSES: [&str; 3] = [TASK_STATUS_UP_NEXT, TASK_STATUS_ON_GOING, TASK_STATUS_DONE];
+
+const TASK_STATUSES_SORT_ORDER: [&str; 3] =
     [TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT, TASK_STATUS_DONE];
 
-// Ascending order: 1 highest priority; 2 medium; 3 lowest
-pub const TASK_PRIORITIES: [u8; 4] = [1, 2, 3, 0];
+// Ascending order: 1 highest priority; 2 medium; 3 lowest; TASK_PRIORITY_NONE = no priority
+pub const TASK_PRIORITIES: [u8; 4] = [1, 2, 3, TASK_PRIORITY_NONE];
 
 impl Task {
-    fn get_status_color(status: &String) -> ratatui::prelude::Color {
-        match status.as_str() {
-            TASK_STATUS_DONE => return Color::LightGreen,
-            TASK_STATUS_ON_GOING => return Color::Yellow,
-            TASK_STATUS_UP_NEXT => return Color::LightMagenta,
-            _ => return Color::Gray,
+    pub fn get_status_color(status: &str) -> ratatui::prelude::Color {
+        match status {
+            TASK_STATUS_DONE => Color::LightGreen,
+            TASK_STATUS_ON_GOING => Color::Yellow,
+            TASK_STATUS_UP_NEXT => Color::LightMagenta,
+            _ => Color::Gray,
         }
     }
 
-    pub fn load_statues_items(items: &mut Vec<ListItem>) {
+    fn current_timestamp() -> u64 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .unwrap()
+            .as_secs()
+    }
+
+    pub fn load_statuses_items(items: &mut Vec<ListItem>) {
         items.clear();
 
         for status in TASK_STATUSES {
-            let span = Span::styled(
-                status,
-                Style::new().fg(Task::get_status_color(&status.to_string())),
-            );
+            let span = Span::styled(status, Style::new().fg(Task::get_status_color(status)));
 
             items.push(ListItem::from(span))
         }
@@ -67,148 +84,649 @@ impl Task {
         let tasks = &mut app.projects[app.selected_project_index.selected().unwrap()].tasks;
 
         let last_task_title_selected = tasks
-            .clone()
             .get(app.selected_task_index.selected().unwrap_or(0))
-            .unwrap_or(&Task {
-                title: "".to_string(),
-                status: "".to_string(),
-                priority: 0,
-            })
-            .clone()
-            .title;
-
-        // Sort by status
+            .map(|t| t.title.clone())
+            .unwrap_or_default();
+
+        // Hand-edited JSON can pair a Done status with a priority; the
+        // sorting invariant (done tasks sort last) and the board rely on
+        // Done implying no priority, so normalize it on every load.
+        for task in tasks.iter_mut() {
+            if task.status == TASK_STATUS_DONE {
+                task.priority = TASK_PRIORITY_NONE;
+            }
+        }
+
+        // Sort by status first, then by priority: `sort_by_key` is stable, so
+        // the last sort wins as the primary key and the final order is
+        // priority-major (status is the tie-breaker within each priority).
+        // Unknown statuses/priorities (hand-edited JSON) map past the end of
+        // the known values so they sort last instead of first (None < Some).
         tasks.sort_by_key(|t| {
             TASK_STATUSES_SORT_ORDER
                 .into_iter()
                 .position(|o| o == t.status)
+                .unwrap_or(TASK_STATUSES_SORT_ORDER.len())
         });
 
-        // Sort by priority
-        tasks.sort_by_key(|t| TASK_PRIORITIES.into_iter().position(|o| o == t.priority));
+        tasks.sort_by_key(|t| {
+            TASK_PRIORITIES
+                .into_iter()
+                .position(|o| o == t.priority)
+                .unwrap_or(TASK_PRIORITIES.len())
+        });
 
         let new_index = tasks
-            .into_iter()
+            .iter()
             .position(|t| t.title == last_task_title_selected)
             .unwrap_or(0);
 
         items.clear();
 
-        for task in tasks.iter() {
-            let modifier = if task.status == TASK_STATUS_DONE {
-                Modifier::CROSSED_OUT
-            } else {
-                Modifier::empty()
-            };
-
-            let mut repr = vec![
-                Span::styled(
-                    format!("[{}] ", task.status),
-                    Style::default()
-                        .fg(Task::get_status_color(&task.status))
-                        .add_modifier(modifier),
-                ),
-                Span::styled(task.title.clone(), Style::default().add_modifier(modifier)),
-            ];
-
-            if task.priority != 0 {
-                let priority_repr = vec![Span::styled(
-                    format!("[{}] ", Util::get_priority_indicator(task.priority)),
-                    Style::new().fg(Color::Red),
-                )];
-                repr = [priority_repr, repr].concat()
+        let mut visible_selected = 0;
+        for (full_idx, task) in tasks.iter().enumerate() {
+            // The board always shows the Done lane, so its item list is the
+            // full sorted list and visible indices match full-list indices
+            if app.hide_done_tasks && !app.board_view && task.status == TASK_STATUS_DONE {
+                continue;
+            }
+            if full_idx == new_index {
+                visible_selected = items.len();
             }
 
-            let line = Line::from(repr);
-
-            items.push(ListItem::from(line))
+            items.push(ListItem::from(Line::from(Task::repr_spans(task, true))))
         }
 
-        app.selected_task_index.select(Some(new_index))
+        app.selected_task_index.select(Some(visible_selected));
+
+        // Keep the board view consistent after any mutation: the selected
+        // task may have changed lane (status change) or disappeared.
+        // List mode is skipped on purpose: its selection is a *visible*
+        // index, which only matches the full-list index the board
+        // reasons in while done tasks sort last.
+        if app.board_view {
+            app.board_sync();
+        }
     }
 
-    pub fn reload(app: &mut App, items: &mut Vec<ListItem>) {
-        app.projects = Json::read();
-        Task::load_items(app, items)
+    /// Spans rendering one task line: `[!]` priority prefix (if any),
+    /// `[status]` prefix (list view only — the board lane already conveys
+    /// the status), the title (crossed out when done), and the `[x%]`
+    /// estimate-progress suffix (when an estimate is set). Shared by the
+    /// list and board views so the two renderings cannot drift apart.
+    pub fn repr_spans(task: &Task, with_status: bool) -> Vec<Span<'static>> {
+        let modifier = if task.status == TASK_STATUS_DONE {
+            Modifier::CROSSED_OUT
+        } else {
+            Modifier::empty()
+        };
+
+        let mut repr = vec![];
+
+        if task.priority != TASK_PRIORITY_NONE {
+            repr.push(Span::styled(
+                format!("[{}] ", Util::get_priority_indicator(task.priority)),
+                Style::new().fg(Color::Red),
+            ));
+        }
+
+        if with_status {
+            repr.push(Span::styled(
+                format!("[{}] ", task.status),
+                Style::default()
+                    .fg(Task::get_status_color(&task.status))
+                    .add_modifier(modifier),
+            ));
+        }
+
+        repr.push(Span::styled(
+            task.title.clone(),
+            Style::default().add_modifier(modifier),
+        ));
+
+        // Estimate progress for tasks with an estimated duration
+        if let Some(pct) = task.estimate_progress(0) {
+            repr.push(Span::styled(
+                format!(" [{}%]", pct),
+                Style::default().fg(if pct >= 100 { Color::Red } else { Color::Cyan }),
+            ));
+        }
+
+        repr
     }
 
-    pub fn _get_all(app: &App) -> &Vec<Task> {
-        return &app.projects[app.selected_project_index.selected().unwrap()].tasks;
+    /// Full-list indices of the tasks in a status lane, in display (sorted)
+    /// order. The board always shows every lane, so `hide_done_tasks` is
+    /// deliberately not applied here.
+    pub fn lane_indices(app: &App, status: &str) -> Vec<usize> {
+        app.projects[app.selected_project_index.selected().unwrap()]
+            .tasks
+            .iter()
+            .enumerate()
+            .filter(|(_, t)| t.status == status)
+            .map(|(i, _)| i)
+            .collect()
     }
 
-    pub fn get_current(app: &mut App) -> &Task {
-        return &app.projects[app.selected_project_index.selected().unwrap()].tasks
-            [app.selected_task_index.selected().unwrap()];
+    pub fn get_current(app: &App) -> &Task {
+        &app.projects[app.selected_project_index.selected().unwrap()].tasks
+            [app.selected_task_index.selected().unwrap()]
     }
 
-    pub fn create(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
+    /// Create a task in the selected project. Returns `false` (without
+    /// touching any data) when the title is empty or already taken by
+    /// another task in the same project: the title is the task's stable
+    /// identity (selection restore, timer binding), so duplicates are
+    /// rejected instead of silently shadowing each other.
+    pub fn create(app: &mut App, items: &mut Vec<ListItem>, value: &str) -> bool {
         if value.is_empty() {
-            return;
+            return false;
         }
 
-        let new_task = Task {
+        let project = &mut app.projects[app.selected_project_index.selected().unwrap()];
+        if project.tasks.iter().any(|t| t.title == value) {
+            return false;
+        }
+
+        project.tasks.push(Task {
             title: value.to_string(),
             status: TASK_STATUS_UP_NEXT.to_string(),
-            priority: 0,
-        };
+            priority: TASK_PRIORITY_NONE,
+            created_at: Some(Self::current_timestamp()),
+            completed_at: None,
+            note: "".to_string(),
+            time_spent_secs: 0,
+            estimated_hours: 0,
+        });
+
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items);
+        true
+    }
+
+    /// Rename the selected task. Returns `false` (without touching any
+    /// data) when another task in the same project already has the new
+    /// title; renaming to the current title is allowed.
+    pub fn rename(app: &mut App, items: &mut Vec<ListItem>, value: &str) -> bool {
+        let project = &mut app.projects[app.selected_project_index.selected().unwrap()];
+        let task_index = app.selected_task_index.selected().unwrap();
 
-        let mut internal_projects = app.projects.clone();
-        internal_projects[app.selected_project_index.selected().unwrap()]
+        if project
             .tasks
-            .push(new_task);
+            .iter()
+            .enumerate()
+            .any(|(i, t)| i != task_index && t.title == value)
+        {
+            return false;
+        }
+
+        project.tasks[task_index].title = value.to_string();
 
-        Json::write(internal_projects);
-        Task::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items);
+        true
     }
 
-    pub fn rename(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
-        let mut internal_projects = app.projects.clone();
+    pub fn update_note(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
+        app.projects[app.selected_project_index.selected().unwrap()].tasks
+            [app.selected_task_index.selected().unwrap()]
+        .note = value.to_string();
 
-        internal_projects[app.selected_project_index.selected().unwrap()].tasks
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items)
+    }
+
+    pub fn update_estimate(app: &mut App, items: &mut Vec<ListItem>, hours: u64) {
+        app.projects[app.selected_project_index.selected().unwrap()].tasks
             [app.selected_task_index.selected().unwrap()]
-        .title = value.to_string();
+        .estimated_hours = hours;
 
-        Json::write(internal_projects);
-        Task::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items)
     }
 
     pub fn change_status(app: &mut App, items: &mut Vec<ListItem>, value: &str) {
-        let mut internal_projects = app.projects.clone();
         let status = value.to_string();
+        let projects = &mut app.projects[app.selected_project_index.selected().unwrap()].tasks;
+        let task = &mut projects[app.selected_task_index.selected().unwrap()];
 
-        internal_projects[app.selected_project_index.selected().unwrap()].tasks
-            [app.selected_task_index.selected().unwrap()]
-        .status = status.clone();
+        task.status = status.clone();
 
         if status == TASK_STATUS_DONE {
-            internal_projects[app.selected_project_index.selected().unwrap()].tasks
-                [app.selected_task_index.selected().unwrap()]
-            .priority = 0
+            task.priority = TASK_PRIORITY_NONE;
+            if task.completed_at.is_none() {
+                task.completed_at = Some(Self::current_timestamp());
+            }
+        } else {
+            task.completed_at = None;
         }
 
-        Json::write(internal_projects);
-        Task::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items)
     }
 
     pub fn change_priority(app: &mut App, items: &mut Vec<ListItem>, value: u8) {
-        let mut internal_projects = app.projects.clone();
-
-        internal_projects[app.selected_project_index.selected().unwrap()].tasks
+        app.projects[app.selected_project_index.selected().unwrap()].tasks
             [app.selected_task_index.selected().unwrap()]
         .priority = value;
 
-        Json::write(internal_projects);
-        Task::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items)
     }
 
-    pub fn delete(app: &mut App, items: &mut Vec<ListItem>) {
-        let mut internal_projects = app.projects.clone();
+    /// Percentage of the estimate already spent, `None` when no estimate is
+    /// set. `extra_secs` accounts for time not yet settled (a running timer).
+    pub fn estimate_progress(&self, extra_secs: u64) -> Option<u64> {
+        if self.estimated_hours == 0 {
+            return None;
+        }
 
-        internal_projects[app.selected_project_index.selected().unwrap()]
+        let pct = self.time_spent_secs.saturating_add(extra_secs) as f64
+            / self.estimated_hours.saturating_mul(3600) as f64
+            * 100.0;
+        Some(pct.round() as u64)
+    }
+
+    /// Accumulate timer seconds into a task, located by project index and
+    /// title (list indexes shift on sort, so the title is the stable identity).
+    /// A task deleted while its timer was running is silently skipped.
+    pub fn add_time_spent(app: &mut App, project_index: usize, task_title: &str, secs: u64) {
+        if secs == 0 {
+            return;
+        }
+
+        let Some(project) = app.projects.get_mut(project_index) else {
+            return;
+        };
+        let Some(task) = project.tasks.iter_mut().find(|t| t.title == task_title) else {
+            return;
+        };
+
+        task.time_spent_secs += secs;
+
+        Json::write(&app.projects).unwrap();
+    }
+
+    pub fn delete(app: &mut App, items: &mut Vec<ListItem>) {
+        app.projects[app.selected_project_index.selected().unwrap()]
             .tasks
             .remove(app.selected_task_index.selected().unwrap());
 
-        Json::write(internal_projects);
-        Task::reload(app, items)
+        Json::write(&app.projects).unwrap();
+        Task::load_items(app, items)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::project::Project;
+    use crate::test_utils::{make_app, make_task, setup_temp_config, ENV_LOCK};
+
+    fn app_with_tasks(tasks: Vec<Task>) -> App {
+        make_app(vec![Project {
+            title: "p".to_string(),
+            tasks,
+        }])
+    }
+
+    #[test]
+    fn create_appends_task_and_persists() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![]);
+        let mut items = vec![];
+
+        Task::create(&mut app, &mut items, "do it");
+
+        let task = &app.projects[0].tasks[0];
+        assert_eq!(task.title, "do it");
+        assert_eq!(task.status, TASK_STATUS_UP_NEXT);
+        assert_eq!(task.priority, TASK_PRIORITY_NONE);
+        assert!(task.created_at.is_some());
+        assert_eq!(items.len(), 1);
+        assert_eq!(Json::read().unwrap(), app.projects);
+    }
+
+    #[test]
+    fn create_with_empty_value_is_a_no_op() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![]);
+        let mut items = vec![];
+
+        assert!(!Task::create(&mut app, &mut items, ""));
+
+        assert!(app.projects[0].tasks.is_empty());
+    }
+
+    #[test]
+    fn create_with_a_duplicate_title_is_rejected() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task("a", TASK_STATUS_UP_NEXT, 1)]);
+        let mut items = vec![];
+        Json::write(&app.projects).unwrap();
+
+        assert!(!Task::create(&mut app, &mut items, "a"));
+
+        assert_eq!(app.projects[0].tasks.len(), 1);
+        assert_eq!(app.projects[0].tasks[0].priority, 1);
+        assert_eq!(Json::read().unwrap(), app.projects);
+    }
+
+    #[test]
+    fn rename_to_a_duplicate_title_is_rejected() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![
+            make_task("a", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+            make_task("b", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+        ]);
+        let mut items = vec![];
+        app.selected_task_index.select(Some(1)); // task "b"
+        Json::write(&app.projects).unwrap();
+
+        assert!(!Task::rename(&mut app, &mut items, "a"));
+
+        assert_eq!(app.projects[0].tasks[1].title, "b");
+        assert_eq!(Json::read().unwrap(), app.projects);
+    }
+
+    #[test]
+    fn rename_to_the_current_title_is_allowed() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "a",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+        let mut items = vec![];
+
+        assert!(Task::rename(&mut app, &mut items, "a"));
+
+        assert_eq!(app.projects[0].tasks[0].title, "a");
+    }
+
+    #[test]
+    fn change_status_to_done_sets_completed_at_and_clears_priority() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task("t", TASK_STATUS_ON_GOING, 1)]);
+        let mut items = vec![];
+        app.hide_done_tasks = false;
+
+        Task::change_status(&mut app, &mut items, TASK_STATUS_DONE);
+
+        let task = &app.projects[0].tasks[0];
+        assert_eq!(task.status, TASK_STATUS_DONE);
+        assert_eq!(task.priority, TASK_PRIORITY_NONE);
+        assert!(task.completed_at.is_some());
+    }
+
+    #[test]
+    fn change_status_away_from_done_clears_completed_at() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut task = make_task("t", TASK_STATUS_DONE, TASK_PRIORITY_NONE);
+        task.completed_at = Some(1_700_000_100);
+        let mut app = app_with_tasks(vec![task]);
+        let mut items = vec![];
+        app.hide_done_tasks = false;
+
+        Task::change_status(&mut app, &mut items, TASK_STATUS_ON_GOING);
+
+        let task = &app.projects[0].tasks[0];
+        assert_eq!(task.status, TASK_STATUS_ON_GOING);
+        assert_eq!(task.completed_at, None);
+    }
+
+    #[test]
+    fn change_priority_updates_selected_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "t",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+        let mut items = vec![];
+
+        Task::change_priority(&mut app, &mut items, 2);
+
+        assert_eq!(app.projects[0].tasks[0].priority, 2);
+    }
+
+    #[test]
+    fn rename_and_update_note_modify_selected_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "old",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+        let mut items = vec![];
+
+        Task::rename(&mut app, &mut items, "new");
+        Task::update_note(&mut app, &mut items, "a note");
+
+        let task = &app.projects[0].tasks[0];
+        assert_eq!(task.title, "new");
+        assert_eq!(task.note, "a note");
+    }
+
+    #[test]
+    fn delete_removes_selected_task() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![
+            make_task("t1", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+            make_task("t2", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+        ]);
+        let mut items = vec![];
+        app.selected_task_index.select(Some(1));
+
+        Task::delete(&mut app, &mut items);
+
+        assert_eq!(app.projects[0].tasks.len(), 1);
+        assert_eq!(app.projects[0].tasks[0].title, "t1");
+    }
+
+    #[test]
+    fn add_time_spent_accumulates_and_persists() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "t",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+
+        Task::add_time_spent(&mut app, 0, "t", 120);
+        Task::add_time_spent(&mut app, 0, "t", 30);
+
+        assert_eq!(app.projects[0].tasks[0].time_spent_secs, 150);
+        assert_eq!(Json::read().unwrap()[0].tasks[0].time_spent_secs, 150);
+    }
+
+    #[test]
+    fn add_time_spent_ignores_zero_secs_and_missing_tasks() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "t",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+
+        Task::add_time_spent(&mut app, 0, "t", 0);
+        Task::add_time_spent(&mut app, 0, "ghost", 60);
+        Task::add_time_spent(&mut app, 9, "t", 60);
+
+        assert_eq!(app.projects[0].tasks[0].time_spent_secs, 0);
+    }
+
+    #[test]
+    fn update_estimate_changes_selected_task_and_persists() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![make_task(
+            "t",
+            TASK_STATUS_UP_NEXT,
+            TASK_PRIORITY_NONE,
+        )]);
+        let mut items = vec![];
+
+        Task::update_estimate(&mut app, &mut items, 500);
+
+        assert_eq!(app.projects[0].tasks[0].estimated_hours, 500);
+        assert_eq!(Json::read().unwrap()[0].tasks[0].estimated_hours, 500);
+    }
+
+    #[test]
+    fn new_tasks_have_no_estimate() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = app_with_tasks(vec![]);
+        let mut items = vec![];
+
+        Task::create(&mut app, &mut items, "do it");
+
+        assert_eq!(app.projects[0].tasks[0].estimated_hours, 0);
+    }
+
+    #[test]
+    fn estimate_progress_is_none_without_estimate() {
+        let mut task = make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE);
+        task.time_spent_secs = 3600;
+        task.estimated_hours = 0;
+
+        assert_eq!(task.estimate_progress(0), None);
+    }
+
+    #[test]
+    fn estimate_progress_rounds_and_includes_extra_secs() {
+        let mut task = make_task("t", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE);
+        task.estimated_hours = 10; // 36000 secs
+
+        task.time_spent_secs = 3600; // 10%
+        assert_eq!(task.estimate_progress(0), Some(10));
+        // extra (unsettled timer) time counts towards the progress
+        assert_eq!(task.estimate_progress(1800), Some(15));
+
+        task.time_spent_secs = 36360; // 101%
+        assert_eq!(task.estimate_progress(0), Some(101));
+    }
+
+    #[test]
+    fn load_items_sorts_by_priority_then_status() {
+        let mut app = app_with_tasks(vec![
+            make_task("done-task", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            make_task("up-next-low", TASK_STATUS_UP_NEXT, 3),
+            make_task("on-going", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+            make_task("up-next-high", TASK_STATUS_UP_NEXT, 1),
+        ]);
+        let mut items = vec![];
+        app.hide_done_tasks = false;
+
+        Task::load_items(&mut app, &mut items);
+
+        let titles: Vec<&str> = app.projects[0]
+            .tasks
+            .iter()
+            .map(|t| t.title.as_str())
+            .collect();
+        // Priority is the primary key (1, 3, then NONE); within the NONE
+        // group the status order applies, so done tasks come last.
+        assert_eq!(
+            titles,
+            vec!["up-next-high", "up-next-low", "on-going", "done-task"]
+        );
+    }
+
+    #[test]
+    fn load_items_hides_done_tasks_when_enabled() {
+        let mut app = app_with_tasks(vec![
+            make_task("visible", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+            make_task("hidden", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+        ]);
+        let mut items = vec![];
+
+        Task::load_items(&mut app, &mut items);
+
+        assert_eq!(items.len(), 1);
+    }
+
+    #[test]
+    fn load_items_sorts_unknown_statuses_and_priorities_last() {
+        let mut app = app_with_tasks(vec![
+            make_task("unknown-status", "Weird", TASK_PRIORITY_NONE),
+            make_task("unknown-priority", TASK_STATUS_UP_NEXT, 9),
+            make_task("done", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+            make_task("normal", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+        ]);
+        let mut items = vec![];
+        app.hide_done_tasks = false;
+
+        Task::load_items(&mut app, &mut items);
+
+        let titles: Vec<&str> = app.projects[0]
+            .tasks
+            .iter()
+            .map(|t| t.title.as_str())
+            .collect();
+        // Priority-major: the known NONE group comes first (status as the
+        // tie-breaker), then the unknown status, then the unknown priority.
+        assert_eq!(
+            titles,
+            vec!["normal", "done", "unknown-status", "unknown-priority"]
+        );
+    }
+
+    #[test]
+    fn load_items_normalizes_done_priorities_from_hand_edited_json() {
+        let mut app = app_with_tasks(vec![make_task("done", TASK_STATUS_DONE, 1)]);
+        let mut items = vec![];
+        app.hide_done_tasks = false;
+
+        Task::load_items(&mut app, &mut items);
+
+        assert_eq!(app.projects[0].tasks[0].priority, TASK_PRIORITY_NONE);
+    }
+
+    #[test]
+    fn load_items_keeps_selection_on_the_same_task_after_resort() {
+        let mut app = app_with_tasks(vec![
+            make_task("a", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+            make_task("b", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+        ]);
+        let mut items = vec![];
+        app.selected_task_index.select(Some(0)); // task "a"
+
+        Task::load_items(&mut app, &mut items);
+
+        let selected = Task::get_current(&app);
+        assert_eq!(selected.title, "a");
+    }
+
+    /// Regression test for the reported crash: after creating a project the
+    /// selection must point at an existing project when opening its tasks.
+    #[test]
+    fn create_project_then_view_tasks_does_not_panic() {
+        let _guard = ENV_LOCK.lock().unwrap();
+        let _dir = setup_temp_config();
+        let mut app = make_app(vec![]);
+        let mut items = vec![];
+
+        Project::create(&mut app, &mut items, "todo");
+        // This is what the fixed AddProject handler does: select the last index
+        app.selected_project_index
+            .select(Some(app.projects.len() - 1));
+
+        Task::load_items(&mut app, &mut items);
+
+        assert!(items.is_empty());
     }
 }
diff --git a/src/test_utils.rs b/src/test_utils.rs
new file mode 100644
index 0000000..07eda0c
--- /dev/null
+++ b/src/test_utils.rs
@@ -0,0 +1,75 @@
+use crate::app::{App, ViewMode};
+use crate::json::Json;
+use crate::project::Project;
+use crate::task::{Task, TASK_PRIORITY_NONE, TASK_STATUS_UP_NEXT};
+use ratatui::widgets::ListState;
+use std::sync::Mutex;
+use tempfile::TempDir;
+
+/// Serializes tests that mutate the process-wide `BASILK_CONFIG_DIR`
+/// env var.
+pub(crate) static ENV_LOCK: Mutex<()> = Mutex::new(());
+
+/// Points the JSON storage at a fresh temporary directory.
+/// The returned `TempDir` must be kept alive for the duration of the test.
+pub(crate) fn setup_temp_config() -> TempDir {
+    let dir = TempDir::new().unwrap();
+    std::env::set_var("BASILK_CONFIG_DIR", dir.path());
+    Json::check().unwrap();
+    dir
+}
+
+pub(crate) fn make_app(projects: Vec<Project>) -> App {
+    App {
+        selected_project_index: ListState::default().with_selected(Some(0)),
+        selected_task_index: ListState::default().with_selected(Some(0)),
+        selected_status_task_index: ListState::default().with_selected(Some(0)),
+        selected_priority_task_index: ListState::default().with_selected(Some(0)),
+        delete_confirm_index: ListState::default().with_selected(Some(0)),
+        view_mode: ViewMode::default(),
+        previous_view_mode: ViewMode::default(),
+        projects,
+        hide_done_tasks: true,
+        timer: None,
+        board_view: false,
+        board_lane: 0,
+        board_lane_states: [
+            ListState::default().with_selected(Some(0)),
+            ListState::default().with_selected(Some(0)),
+            ListState::default().with_selected(Some(0)),
+        ],
+        notes: vec![],
+        selected_note_index: ListState::default().with_selected(Some(0)),
+        note_scroll: 0,
+        note_textarea: None,
+    }
+}
+
+pub(crate) fn make_task(title: &str, status: &str, priority: u8) -> Task {
+    Task {
+        title: title.to_string(),
+        status: status.to_string(),
+        priority,
+        created_at: Some(1_700_000_000),
+        completed_at: None,
+        note: String::new(),
+        time_spent_secs: 0,
+        estimated_hours: 0,
+    }
+}
+
+pub(crate) fn sample_projects() -> Vec<Project> {
+    vec![
+        Project {
+            title: "alpha".to_string(),
+            tasks: vec![
+                make_task("a1", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE),
+                make_task("a2", TASK_STATUS_UP_NEXT, 1),
+            ],
+        },
+        Project {
+            title: "beta".to_string(),
+            tasks: vec![],
+        },
+    ]
+}
diff --git a/src/timer.rs b/src/timer.rs
new file mode 100644
index 0000000..1a33b69
--- /dev/null
+++ b/src/timer.rs
@@ -0,0 +1,202 @@
+use std::time::{Duration, Instant};
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum TimerKind {
+    /// Task-bound, open-ended; accumulates into the task's `time_spent_secs`.
+    Stopwatch,
+    /// Global pomodoro; not bound to any task, nothing is persisted.
+    Countdown,
+}
+
+/// The task a stopwatch timer accumulates time into (list indexes shift on
+/// sort, so the title is the stable identity, mirroring `Task::load_items`).
+#[derive(Debug, Clone)]
+pub struct TimerTaskBinding {
+    pub project_index: usize,
+    pub task_title: String,
+}
+
+/// Runtime state of a timer. Not persisted; a stopwatch settles its elapsed
+/// seconds into the bound task, a countdown (pomodoro) never accumulates
+/// anything — at zero it rings the bell once and stays in the finished
+/// state until the user dismisses it.
+#[derive(Debug, Clone)]
+pub struct TimerState {
+    pub kind: TimerKind,
+    /// Countdown target in seconds (unused for stopwatch).
+    pub target_secs: u64,
+    /// Time accumulated across pause/resume cycles.
+    pub accumulated: Duration,
+    /// `Some` while the timer is running.
+    pub started_at: Option<Instant>,
+    /// Task binding (stopwatch only).
+    pub bound: Option<TimerTaskBinding>,
+    /// Countdown only: set once the terminal bell has been rung at zero,
+    /// so it rings exactly once while the finished timer stays visible.
+    pub rung: bool,
+}
+
+impl TimerState {
+    pub fn new_stopwatch(project_index: usize, task_title: String) -> Self {
+        Self {
+            kind: TimerKind::Stopwatch,
+            target_secs: 0,
+            accumulated: Duration::ZERO,
+            started_at: Some(Instant::now()),
+            bound: Some(TimerTaskBinding {
+                project_index,
+                task_title,
+            }),
+            rung: false,
+        }
+    }
+
+    pub fn new_countdown(target_secs: u64) -> Self {
+        Self {
+            kind: TimerKind::Countdown,
+            target_secs,
+            accumulated: Duration::ZERO,
+            started_at: Some(Instant::now()),
+            bound: None,
+            rung: false,
+        }
+    }
+
+    /// Whether this timer is bound to the given task.
+    pub fn is_bound_to(&self, project_index: usize, task_title: &str) -> bool {
+        self.bound
+            .as_ref()
+            .is_some_and(|b| b.project_index == project_index && b.task_title == task_title)
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        let running = self.started_at.map_or(Duration::ZERO, |t| t.elapsed());
+        self.accumulated + running
+    }
+
+    /// `None` for stopwatch; `Some(remaining)` for countdown (zero once done).
+    pub fn remaining(&self) -> Option<Duration> {
+        if self.kind != TimerKind::Countdown {
+            return None;
+        }
+        let target = Duration::from_secs(self.target_secs);
+        Some(target.saturating_sub(self.elapsed()))
+    }
+
+    pub fn is_running(&self) -> bool {
+        self.started_at.is_some()
+    }
+
+    /// `true` once a countdown has run down to zero (stopwatches never finish).
+    pub fn is_finished(&self) -> bool {
+        self.remaining() == Some(Duration::ZERO)
+    }
+
+    pub fn pause(&mut self) {
+        if let Some(started) = self.started_at.take() {
+            self.accumulated += started.elapsed();
+        }
+    }
+
+    pub fn resume(&mut self) {
+        if self.started_at.is_none() {
+            self.started_at = Some(Instant::now());
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn paused_timer(kind: TimerKind, accumulated_secs: u64, target_secs: u64) -> TimerState {
+        let bound = if kind == TimerKind::Stopwatch {
+            Some(TimerTaskBinding {
+                project_index: 0,
+                task_title: "t".to_string(),
+            })
+        } else {
+            None
+        };
+        TimerState {
+            kind,
+            target_secs,
+            accumulated: Duration::from_secs(accumulated_secs),
+            started_at: None,
+            bound,
+            rung: false,
+        }
+    }
+
+    #[test]
+    fn new_timers_start_running() {
+        assert!(TimerState::new_stopwatch(0, "t".to_string()).is_running());
+        assert!(TimerState::new_countdown(1500).is_running());
+    }
+
+    #[test]
+    fn stopwatch_is_bound_and_countdown_is_global() {
+        let stopwatch = TimerState::new_stopwatch(1, "t".to_string());
+        assert!(stopwatch.is_bound_to(1, "t"));
+        assert!(!stopwatch.is_bound_to(0, "t"));
+        assert!(!stopwatch.is_bound_to(1, "other"));
+
+        let countdown = TimerState::new_countdown(60);
+        assert!(countdown.bound.is_none());
+        assert!(!countdown.is_bound_to(0, "t"));
+    }
+
+    #[test]
+    fn countdown_stores_target_secs() {
+        let timer = TimerState::new_countdown(1500);
+        assert_eq!(timer.target_secs, 1500);
+    }
+
+    #[test]
+    fn elapsed_is_accumulated_when_paused() {
+        let timer = paused_timer(TimerKind::Stopwatch, 90, 0);
+        assert_eq!(timer.elapsed(), Duration::from_secs(90));
+    }
+
+    #[test]
+    fn pause_freezes_elapsed_and_resume_continues() {
+        let mut timer = TimerState::new_stopwatch(0, "t".to_string());
+        timer.pause();
+        let frozen = timer.elapsed();
+        std::thread::sleep(Duration::from_millis(20));
+        assert_eq!(timer.elapsed(), frozen);
+        assert!(!timer.is_running());
+
+        timer.resume();
+        assert!(timer.is_running());
+        std::thread::sleep(Duration::from_millis(20));
+        assert!(timer.elapsed() >= frozen);
+    }
+
+    #[test]
+    fn remaining_is_none_for_stopwatch() {
+        let timer = paused_timer(TimerKind::Stopwatch, 90, 0);
+        assert_eq!(timer.remaining(), None);
+    }
+
+    #[test]
+    fn remaining_counts_down_to_zero() {
+        let timer = paused_timer(TimerKind::Countdown, 60, 90);
+        assert_eq!(timer.remaining(), Some(Duration::from_secs(30)));
+
+        let overtime = paused_timer(TimerKind::Countdown, 120, 90);
+        assert_eq!(overtime.remaining(), Some(Duration::ZERO));
+    }
+
+    #[test]
+    fn only_a_run_down_countdown_is_finished() {
+        let done = paused_timer(TimerKind::Countdown, 120, 90);
+        assert!(done.is_finished());
+
+        let running = paused_timer(TimerKind::Countdown, 60, 90);
+        assert!(!running.is_finished());
+
+        let stopwatch = paused_timer(TimerKind::Stopwatch, 120, 0);
+        assert!(!stopwatch.is_finished());
+    }
+}
diff --git a/src/ui.rs b/src/ui.rs
index d30e2b4..f43824d 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -1,6 +1,5 @@
 use ratatui::{
-    layout::{Alignment, Constraint, Layout, Rect},
-    text::{Line, Text},
+    layout::{Constraint, Layout, Rect},
     widgets::{Block, Borders, Clear, Paragraph, Widget},
     Frame,
 };
@@ -9,30 +8,36 @@ use tui_input::Input;
 pub struct Ui {}
 
 impl Ui {
-    pub fn create_rect_area(percent_x: u16, percent_y: u16, r: Rect) -> Rect {
+    /// Center a popup of `width_pct` percent of the area width and
+    /// `height_rows` absolute rows (not a percentage) inside `r`.
+    pub fn create_rect_area(width_pct: u16, height_rows: u16, r: Rect) -> Rect {
+        let width_pct = width_pct.min(100);
+        let content_height = height_rows.min(r.height.saturating_sub(2));
+        let vertical_margin = (r.height.saturating_sub(content_height)) / 2;
+
         let popup_layout = Layout::vertical([
-            Constraint::Percentage((100 - percent_y) / 2),
-            Constraint::Min(percent_y),
-            Constraint::Percentage((100 - percent_y) / 2),
+            Constraint::Length(vertical_margin),
+            Constraint::Length(content_height),
+            Constraint::Min(vertical_margin),
         ])
         .split(r);
 
         Layout::horizontal([
-            Constraint::Percentage((100 - percent_x) / 2),
-            Constraint::Min(percent_x),
-            Constraint::Percentage((100 - percent_x) / 2),
+            Constraint::Percentage((100 - width_pct) / 2),
+            Constraint::Min(width_pct),
+            Constraint::Percentage((100 - width_pct) / 2),
         ])
         .split(popup_layout[1])[1]
     }
 
     pub fn create_modal<W: Widget>(
         f: &mut Frame,
-        percent_x: u16,
-        percent_y: u16,
+        width_pct: u16,
+        height_rows: u16,
         area: Rect,
         widget: W,
     ) {
-        let area = Ui::create_rect_area(percent_x, percent_y, area);
+        let area = Ui::create_rect_area(width_pct, height_rows, area);
         f.render_widget(Clear, area); //this clears out the background
         f.render_widget(widget, area);
     }
@@ -57,25 +62,4 @@ impl Ui {
             area.y + 1,
         )
     }
-
-    pub fn create_question_modal(
-        text_first_line: &str,
-        text_second_line: &str,
-        title: &str,
-        f: &mut Frame,
-        area: Rect,
-    ) {
-        let area = Ui::create_rect_area(20, 4, area);
-
-        f.render_widget(Clear, area); //this clears out the background
-        f.render_widget(
-            Paragraph::new(Text::from(vec![
-                Line::raw(text_first_line),
-                Line::raw(text_second_line),
-            ]))
-            .alignment(Alignment::Center)
-            .block(Block::bordered().title(title)),
-            area,
-        );
-    }
 }
diff --git a/src/util.rs b/src/util.rs
index 1d49339..5bf73f9 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,4 +1,6 @@
-use crate::task::TASK_PRIORITIES;
+use chrono::{DateTime, Local};
+
+use crate::task::{TASK_PRIORITIES, TASK_PRIORITY_NONE};
 
 pub struct Util;
 
@@ -13,7 +15,7 @@ impl Util {
         // priority: 1 => !!!
         // priority: 2 => !!
         // priority: 3 => !
-        let priority_value = if value == 0 {
+        let priority_value = if value == TASK_PRIORITY_NONE {
             0
         } else {
             TASK_PRIORITIES
@@ -23,6 +25,102 @@ impl Util {
                 .unwrap_or(0)
         };
 
-        "!!!".chars().take((priority_value).into()).collect()
+        "!!!".chars().take(priority_value).collect()
+    }
+
+    /// Format a plain seconds count as HH:MM:SS (timer readouts).
+    pub fn format_secs(secs: u64) -> String {
+        format!(
+            "{:02}:{:02}:{:02}",
+            secs / 3600,
+            (secs % 3600) / 60,
+            secs % 60
+        )
+    }
+
+    pub fn format_timestamp(timestamp: Option<u64>) -> String {
+        timestamp
+            .and_then(|ts| DateTime::from_timestamp(ts as i64, 0))
+            .map(|dt| {
+                let local_dt: DateTime<Local> = dt.into();
+                local_dt.format("%Y-%m-%d %H:%M:%S %z").to_string()
+            })
+            .unwrap_or_else(|| "N/A".to_string())
+    }
+
+    pub fn format_duration(start: Option<u64>, end: Option<u64>) -> String {
+        match (start, end) {
+            (Some(s), Some(e)) => {
+                if e > s {
+                    let duration_secs = e - s;
+                    let days = duration_secs / 86400;
+                    let hours = (duration_secs % 86400) / 3600;
+                    let minutes = (duration_secs % 3600) / 60;
+                    let seconds = duration_secs % 60;
+
+                    if days > 0 {
+                        format!("{}d {}h {}m {}s", days, hours, minutes, seconds)
+                    } else if hours > 0 {
+                        format!("{}h {}m {}s", hours, minutes, seconds)
+                    } else if minutes > 0 {
+                        format!("{}m {}s", minutes, seconds)
+                    } else {
+                        format!("{}s", seconds)
+                    }
+                } else {
+                    "Invalid time range".to_string()
+                }
+            }
+            _ => "Task not completed".to_string(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn spaced_title_wraps_with_spaces() {
+        assert_eq!(Util::get_spaced_title("hello"), " hello ");
+    }
+
+    #[test]
+    fn priority_indicator_mapping() {
+        assert_eq!(Util::get_priority_indicator(TASK_PRIORITY_NONE), "");
+        assert_eq!(Util::get_priority_indicator(1), "!!!");
+        assert_eq!(Util::get_priority_indicator(2), "!!");
+        assert_eq!(Util::get_priority_indicator(3), "!");
+        // Unknown values fall back to an empty indicator
+        assert_eq!(Util::get_priority_indicator(99), "");
+    }
+
+    #[test]
+    fn format_secs_renders_hh_mm_ss() {
+        assert_eq!(Util::format_secs(0), "00:00:00");
+        assert_eq!(Util::format_secs(59), "00:00:59");
+        assert_eq!(Util::format_secs(60), "00:01:00");
+        assert_eq!(Util::format_secs(3661), "01:01:01");
+        assert_eq!(Util::format_secs(90_061), "25:01:01");
+    }
+
+    #[test]
+    fn format_timestamp_handles_none_and_epoch() {
+        assert_eq!(Util::format_timestamp(None), "N/A");
+        assert!(Util::format_timestamp(Some(0)).contains("1970-01-01"));
+    }
+
+    #[test]
+    fn format_duration_variants() {
+        assert_eq!(Util::format_duration(None, Some(10)), "Task not completed");
+        assert_eq!(Util::format_duration(Some(10), None), "Task not completed");
+        assert_eq!(
+            Util::format_duration(Some(10), Some(10)),
+            "Invalid time range"
+        );
+        assert_eq!(Util::format_duration(Some(0), Some(45)), "45s");
+        assert_eq!(Util::format_duration(Some(0), Some(90)), "1m 30s");
+        assert_eq!(Util::format_duration(Some(0), Some(3700)), "1h 1m 40s");
+        assert_eq!(Util::format_duration(Some(0), Some(90061)), "1d 1h 1m 1s");
     }
 }
diff --git a/src/view.rs b/src/view.rs
index 9ccebbd..9382152 100644
--- a/src/view.rs
+++ b/src/view.rs
@@ -1,16 +1,75 @@
 use ratatui::{
-    layout::{Alignment, Rect},
-    style::{Modifier, Style},
-    text::{Line, Text},
+    layout::{Alignment, Constraint, Layout, Rect},
+    style::{Color, Modifier, Style},
+    text::{Line, Span, Text},
     widgets::{Block, Clear, HighlightSpacing, List, ListItem, Paragraph, Wrap},
     Frame,
 };
 use tui_input::Input;
 
-use crate::{project::Project, task::Task, ui::Ui, util::Util, App, ViewMode};
+use crate::{
+    app::{App, ViewMode},
+    markdown::render_markdown,
+    note::Note,
+    project::Project,
+    task::{Task, TASK_PRIORITY_NONE, TASK_STATUSES},
+    timer::TimerKind,
+    ui::Ui,
+    util::Util,
+};
 
 pub struct View {}
 
+/// Approximate number of lines a paragraph occupies once wrapped to
+/// `width` columns (ratatui 0.27 keeps `Paragraph::line_count` private).
+/// Word wrapping can produce slightly more lines than this estimate;
+/// it is only used to clamp the note preview scroll offset.
+fn wrapped_line_count(text: &Text, width: u16) -> usize {
+    let width = usize::from(width).max(1);
+
+    text.lines
+        .iter()
+        .map(|line| line.width().div_ceil(width))
+        .map(|n| n.max(1))
+        .sum()
+}
+
+/// One 5-row block glyph for a digit or colon in the big timer readout.
+fn digit_glyph(c: char) -> [&'static str; 5] {
+    match c {
+        '0' => ["███", "█ █", "█ █", "█ █", "███"],
+        '1' => ["  █", "  █", "  █", "  █", "  █"],
+        '2' => ["███", "  █", "███", "█  ", "███"],
+        '3' => ["███", "  █", "███", "  █", "███"],
+        '4' => ["█ █", "█ █", "███", "  █", "  █"],
+        '5' => ["███", "█  ", "███", "  █", "███"],
+        '6' => ["███", "█  ", "███", "█ █", "███"],
+        '7' => ["███", "  █", "  █", "  █", "  █"],
+        '8' => ["███", "█ █", "███", "█ █", "███"],
+        '9' => ["███", "█ █", "███", "  █", "███"],
+        ':' => [" ", "█", " ", "█", " "],
+        _ => ["   ", "   ", "   ", "   ", "   "],
+    }
+}
+
+/// Render an HH:MM:SS readout as 5-row block digits so the timer is
+/// readable at a glance instead of a single text line.
+fn big_digit_lines(readout: &str, color: Color) -> Vec<Line<'static>> {
+    (0..5)
+        .map(|row| {
+            let text = readout
+                .chars()
+                .map(|c| digit_glyph(c)[row])
+                .collect::<Vec<_>>()
+                .join(" ");
+            Line::from(Span::styled(
+                text,
+                Style::default().fg(color).add_modifier(Modifier::BOLD),
+            ))
+        })
+        .collect()
+}
+
 impl View {
     pub fn show_new_item_modal(f: &mut Frame, area: Rect, input: &Input) {
         Ui::create_input_modal("New", f, area, input)
@@ -31,31 +90,172 @@ impl View {
         Ui::create_input_modal("Rename", f, area, input)
     }
 
+    pub fn show_edit_note_modal(f: &mut Frame, area: Rect, input: &Input) {
+        Ui::create_input_modal("Note", f, area, input)
+    }
+
+    pub fn show_countdown_modal(f: &mut Frame, area: Rect, input: &Input) {
+        Ui::create_input_modal("Countdown (minutes)", f, area, input)
+    }
+
+    pub fn show_task_estimate_modal(f: &mut Frame, area: Rect, input: &Input) {
+        Ui::create_input_modal("Estimate (hours, 0 = none)", f, area, input)
+    }
+
+    pub fn show_timer_modal(app: &App, f: &mut Frame, area: Rect) {
+        let Some(timer) = app.timer.as_ref() else {
+            return;
+        };
+
+        let finished = timer.is_finished();
+
+        let (readout, target) = match timer.kind {
+            TimerKind::Stopwatch => (Util::format_secs(timer.elapsed().as_secs()), None),
+            TimerKind::Countdown => (
+                Util::format_secs(timer.remaining().unwrap_or_default().as_secs()),
+                Some(Util::format_secs(timer.target_secs)),
+            ),
+        };
+
+        let running_low = timer.is_running()
+            && timer.kind == TimerKind::Countdown
+            && timer.remaining().unwrap_or_default().as_secs() <= 10;
+
+        let readout_color = if finished || running_low {
+            Color::Red
+        } else if timer.is_running() {
+            Color::Green
+        } else {
+            Color::Yellow
+        };
+
+        let mut lines = vec![Line::raw("")];
+        lines.extend(big_digit_lines(&readout, readout_color));
+        lines.push(Line::raw(""));
+
+        if let Some(target) = target {
+            lines.push(Line::from(Span::styled(
+                format!("of {}", target),
+                Style::default().fg(Color::DarkGray),
+            )));
+            lines.push(Line::raw(""));
+        }
+
+        match &timer.bound {
+            Some(bound) => {
+                lines.push(Line::from(vec![
+                    Span::styled("Task: ", Style::default().fg(Color::Cyan)),
+                    Span::raw(&bound.task_title),
+                ]));
+                lines.push(Line::raw(""));
+
+                // Live estimate progress, including the unsettled time on this timer
+                let estimate_line = app
+                    .projects
+                    .get(bound.project_index)
+                    .and_then(|p| p.tasks.iter().find(|t| t.title == bound.task_title))
+                    .and_then(|t| {
+                        t.estimate_progress(timer.elapsed().as_secs())
+                            .map(|pct| (t.estimated_hours, pct))
+                    });
+
+                if let Some((hours, pct)) = estimate_line {
+                    lines.push(Line::from(vec![
+                        Span::styled("Estimate: ", Style::default().fg(Color::Cyan)),
+                        Span::styled(
+                            format!("{}h ({}% spent)", hours, pct),
+                            Style::default().fg(if pct >= 100 {
+                                Color::Red
+                            } else {
+                                Color::DarkGray
+                            }),
+                        ),
+                    ]));
+                    lines.push(Line::raw(""));
+                }
+            }
+            None => {
+                lines.push(Line::from(Span::styled(
+                    "pomodoro",
+                    Style::default().fg(Color::Cyan),
+                )));
+                lines.push(Line::raw(""));
+            }
+        }
+
+        let status = if finished {
+            "time's up!"
+        } else if timer.is_running() {
+            "running"
+        } else {
+            "paused"
+        };
+        lines.push(Line::from(Span::styled(
+            status,
+            Style::default().fg(Color::DarkGray),
+        )));
+        lines.push(Line::raw(""));
+        lines.push(Line::from(Span::styled(
+            if finished {
+                "Press any key to close"
+            } else {
+                "Space pause/resume · Enter stop · Esc background"
+            },
+            Style::default()
+                .fg(Color::DarkGray)
+                .add_modifier(Modifier::ITALIC),
+        )));
+
+        let title = match timer.kind {
+            TimerKind::Stopwatch => " Timer ",
+            TimerKind::Countdown => " Pomodoro ",
+        };
+
+        let widget = Paragraph::new(Text::from(lines))
+            .alignment(Alignment::Center)
+            .block(Block::bordered().title(title));
+
+        Ui::create_modal(f, 60, 18, area, widget)
+    }
+
     pub fn show_delete_item_modal(app: &mut App, f: &mut Frame, area: Rect) {
         let title = match app.view_mode {
             ViewMode::DeleteTask => &Task::get_current(app).title,
             ViewMode::DeleteProject => &Project::get_current(app).title,
+            ViewMode::DeleteNote => &Note::get_current(app).title,
             _ => "",
         };
 
-        Ui::create_question_modal(
-            "Are you sure to delete?",
-            format!("\"{}\"", title).as_str(),
-            "Delete",
-            f,
-            area,
-        )
+        let area = Ui::create_rect_area(30, 5, area);
+
+        let list_widget = List::new(View::delete_confirm_items())
+            .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+            .highlight_symbol("> ")
+            .highlight_spacing(HighlightSpacing::Always)
+            .block(Block::bordered().title(format!("Delete \"{}\"?", title)));
+
+        f.render_widget(Clear, area);
+        f.render_stateful_widget(list_widget, area, app.use_state())
+    }
+
+    /// The two fixed options of every delete confirmation. Shared with the
+    /// delete key handlers, which only need the option count for navigation.
+    pub(crate) fn delete_confirm_items() -> Vec<ListItem<'static>> {
+        vec![
+            ListItem::from(Span::styled("Confirm", Style::new().fg(Color::Red))),
+            ListItem::from(Span::styled("Cancel", Style::new().fg(Color::Gray))),
+        ]
     }
 
     pub fn show_select_task_status_modal(
         app: &mut App,
-        status_items: &Vec<ListItem>,
+        status_items: &[ListItem],
         f: &mut Frame,
         area: Rect,
     ) {
-        let area = Ui::create_rect_area(10, 5, area);
+        let area = Ui::create_rect_area(20, 5, area);
 
-        let task_status_list_widget = List::new(status_items.clone())
+        let task_status_list_widget = List::new(status_items.to_vec())
             .highlight_style(Style::default().add_modifier(Modifier::BOLD))
             .highlight_symbol("> ")
             .highlight_spacing(HighlightSpacing::Always)
@@ -67,13 +267,13 @@ impl View {
 
     pub fn show_select_task_priority_modal(
         app: &mut App,
-        priority_items: &Vec<ListItem>,
+        priority_items: &[ListItem],
         f: &mut Frame,
         area: Rect,
     ) {
-        let area = Ui::create_rect_area(10, 6, area);
+        let area = Ui::create_rect_area(20, 6, area);
 
-        let task_status_list_widget = List::new(priority_items.clone())
+        let task_status_list_widget = List::new(priority_items.to_vec())
             .highlight_style(Style::default().add_modifier(Modifier::BOLD))
             .highlight_symbol("> ")
             .highlight_spacing(HighlightSpacing::Always)
@@ -83,17 +283,51 @@ impl View {
         f.render_stateful_widget(task_status_list_widget, area, app.use_state())
     }
 
-    pub fn show_items(app: &mut App, items: &Vec<ListItem>, f: &mut Frame, area: Rect) {
-        let block: Block = match app.view_mode {
-            ViewMode::ViewProjects
-            | ViewMode::AddProject
-            | ViewMode::RenameProject
-            | ViewMode::DeleteProject => Block::bordered(),
-            _ => Block::bordered().title(Util::get_spaced_title(&Project::get_current(app).title)),
+    pub fn show_items(app: &mut App, items: &[ListItem], f: &mut Frame, area: Rect) {
+        // Timer modals show the list of the view they were opened from;
+        // the help modal shows the list of the view it was opened from
+        // (classified via `previous_view_mode`). Without this, opening
+        // help over the projects/notes view would fall into the tasks
+        // branch and call `Project::get_current`, which panics when the
+        // project list is empty (or its selection was cleared by an
+        // empty-list render).
+        let from_projects =
+            matches!(
+                app.view_mode,
+                ViewMode::ViewProjects
+                    | ViewMode::AddProject
+                    | ViewMode::RenameProject
+                    | ViewMode::DeleteProject
+                    | ViewMode::InfoMigration
+            ) || (matches!(app.view_mode, ViewMode::TimerTask | ViewMode::SetCountdown)
+                && app.previous_view_mode == ViewMode::ViewProjects)
+                || (app.view_mode == ViewMode::ViewHelp
+                    && app.previous_view_mode == ViewMode::ViewProjects);
+
+        let from_notes = matches!(
+            app.view_mode,
+            ViewMode::ViewNotes | ViewMode::AddNote | ViewMode::RenameNote | ViewMode::DeleteNote
+        ) || (app.view_mode == ViewMode::ViewHelp
+            && matches!(
+                app.previous_view_mode,
+                ViewMode::ViewNotes | ViewMode::ViewNote | ViewMode::EditNote
+            ));
+
+        if !from_projects && !from_notes && app.board_view {
+            View::show_board(app, f, area);
+            return;
+        }
+
+        let block: Block = if from_projects {
+            Block::bordered()
+        } else if from_notes {
+            Block::bordered().title(" Notes ")
+        } else {
+            Block::bordered().title(Util::get_spaced_title(&Project::get_current(app).title))
         };
 
         // Iterate through all elements in the `items` and stylize them.
-        let items = items.clone();
+        let items = items.to_vec();
 
         // Create a List from all list items and highlight the currently selected one
         let items = List::new(items)
@@ -104,6 +338,9 @@ impl View {
 
         if app.view_mode == ViewMode::ChangeStatusTask
             || app.view_mode == ViewMode::ChangePriorityTask
+            || app.view_mode == ViewMode::DeleteTask
+            || app.view_mode == ViewMode::DeleteProject
+            || app.view_mode == ViewMode::DeleteNote
         {
             f.render_widget(items, area)
         } else {
@@ -111,31 +348,503 @@ impl View {
         }
     }
 
-    pub fn show_footer_helper(app: &mut App, f: &mut Frame, area: Rect) {
-        let help_string = match app.view_mode {
-            ViewMode::ViewProjects => {
-                "<Up/Down k/j> next/prev - <Enter/Right/l> go to tasks - <n> new - <r> rename - <d> delete - <q> quit"
-            }
-            ViewMode::RenameProject => "<Enter> confirm - <Esc> cancel",
-            ViewMode::AddProject => "<Enter> confirm - <Esc> cancel",
-            ViewMode::DeleteProject => "<y> confirm - <n> cancel",
+    /// Kanban-style board: one vertical lane per task status. The focused
+    /// lane gets the status color for its border and title; every lane is
+    /// always shown (the Done lane ignores `hide_done_tasks`).
+    pub fn show_board(app: &mut App, f: &mut Frame, area: Rect) {
+        const LANE_TITLES: [&str; 3] = ["Up Next", "On Going", "Done"];
+
+        let outer =
+            Block::bordered().title(Util::get_spaced_title(&Project::get_current(app).title));
+        let inner = outer.inner(area);
+        f.render_widget(outer, area);
+
+        let columns = Layout::horizontal([
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+            Constraint::Ratio(1, 3),
+        ])
+        .spacing(1)
+        .split(inner);
+
+        for (lane, status) in TASK_STATUSES.into_iter().enumerate() {
+            let indices = Task::lane_indices(app, status);
+            let status_color = Task::get_status_color(status);
+            let focused = lane == app.board_lane;
+
+            let lane_style = if focused {
+                Style::default()
+                    .fg(status_color)
+                    .add_modifier(Modifier::BOLD)
+            } else {
+                Style::default().fg(Color::DarkGray)
+            };
+
+            let lane_block = Block::bordered()
+                .title(Line::from(Span::styled(
+                    format!(" {} ({}) ", LANE_TITLES[lane], indices.len()),
+                    if focused {
+                        lane_style
+                    } else {
+                        Style::default()
+                    },
+                )))
+                .border_style(lane_style);
 
-            ViewMode::ViewTasks => {
-                "<Up/Down k/j> next/prev - <Esc/Left/h> go to projects - <Enter> change status - <p> change priority - <n> new - <r> rename - <d> delete - <q> quit"
+            if indices.is_empty() {
+                let placeholder = Paragraph::new(Line::from(Span::styled(
+                    "(empty)",
+                    Style::default()
+                        .fg(Color::DarkGray)
+                        .add_modifier(Modifier::ITALIC),
+                )))
+                .alignment(Alignment::Center)
+                .block(lane_block);
+
+                f.render_widget(placeholder, columns[lane]);
+                continue;
             }
-            ViewMode::RenameTask => "<Enter> confirm - <Esc> cancel",
-            ViewMode::ChangeStatusTask => "<Up/Down k/j> next/prev - <Enter> confirm - <Esc> cancel",
-            ViewMode::ChangePriorityTask => "<Up/Down k/j> next/prev - <Enter> confirm - <Esc> cancel",
-            ViewMode::AddTask => "<Enter> confirm - <Esc> cancel",
-            ViewMode::DeleteTask => "<y> confirm - <n> cancel",
-            ViewMode::InfoMigration => ""
+
+            // Own every string so the item list outlives the `tasks` borrow
+            // (the mutable lane state is borrowed again at render time).
+            let lane_items: Vec<ListItem> = {
+                let tasks = &app.projects[app.selected_project_index.selected().unwrap()].tasks;
+
+                indices
+                    .iter()
+                    .map(|&i| ListItem::new(Line::from(Task::repr_spans(&tasks[i], false))))
+                    .collect()
+            };
+
+            let list = List::new(lane_items)
+                .highlight_style(Style::default().add_modifier(Modifier::BOLD))
+                .highlight_symbol("> ")
+                .highlight_spacing(HighlightSpacing::Always)
+                .block(lane_block);
+
+            f.render_stateful_widget(list, columns[lane], &mut app.board_lane_states[lane]);
+        }
+    }
+
+    pub fn show_task_details_modal(app: &mut App, f: &mut Frame, area: Rect) {
+        let task = Task::get_current(app);
+
+        let priority_text = if task.priority == TASK_PRIORITY_NONE {
+            "None".to_string()
+        } else {
+            format!(
+                "{} ({})",
+                task.priority,
+                Util::get_priority_indicator(task.priority)
+            )
+        };
+
+        let mut lines = vec![
+            Line::from(vec![
+                Span::styled(
+                    "Task: ",
+                    Style::default()
+                        .fg(Color::Cyan)
+                        .add_modifier(Modifier::BOLD),
+                ),
+                Span::raw(&task.title),
+            ]),
+            Line::raw(""),
+            Line::from(vec![
+                Span::styled("Status: ", Style::default().fg(Color::Cyan)),
+                Span::styled(
+                    &task.status,
+                    Style::default().fg(Task::get_status_color(&task.status)),
+                ),
+            ]),
+            Line::raw(""),
+            Line::from(vec![
+                Span::styled("Priority: ", Style::default().fg(Color::Cyan)),
+                Span::styled(priority_text, Style::default().fg(Color::Red)),
+            ]),
+            Line::raw(""),
+            Line::from(vec![
+                Span::styled("Note: ", Style::default().fg(Color::Cyan)),
+                Span::raw(&task.note),
+            ]),
+            Line::raw(""),
+        ];
+
+        // Add creation time if available
+        if task.created_at.is_some() {
+            lines.push(Line::from(vec![
+                Span::styled("Created: ", Style::default().fg(Color::Cyan)),
+                Span::raw(Util::format_timestamp(task.created_at)),
+            ]));
+            lines.push(Line::raw(""));
+        }
+
+        // Add completion time if available
+        if task.completed_at.is_some() {
+            lines.push(Line::from(vec![
+                Span::styled("Completed: ", Style::default().fg(Color::Cyan)),
+                Span::raw(Util::format_timestamp(task.completed_at)),
+            ]));
+            lines.push(Line::raw(""));
+        }
+
+        // Show the consumed time whenever a creation timestamp exists;
+        // format_duration prints "Task not completed" without an end
+        if task.created_at.is_some() {
+            lines.push(Line::from(vec![
+                Span::styled("Time Consumed: ", Style::default().fg(Color::Cyan)),
+                Span::raw(Util::format_duration(task.created_at, task.completed_at)),
+            ]));
+            lines.push(Line::raw(""));
+        }
+
+        // Accumulated timer time vs. the estimated duration
+        lines.push(Line::from(vec![
+            Span::styled("Time Spent: ", Style::default().fg(Color::Cyan)),
+            Span::raw(format!(
+                "{}h {}m ({})",
+                task.time_spent_secs / 3600,
+                (task.time_spent_secs % 3600) / 60,
+                Util::format_secs(task.time_spent_secs),
+            )),
+        ]));
+        lines.push(Line::raw(""));
+
+        let estimate_text = match task.estimate_progress(0) {
+            Some(pct) => format!("{}h ({}% spent)", task.estimated_hours, pct),
+            None => "none".to_string(),
+        };
+        lines.push(Line::from(vec![
+            Span::styled("Estimate: ", Style::default().fg(Color::Cyan)),
+            Span::raw(estimate_text),
+        ]));
+        lines.push(Line::raw(""));
+
+        lines.push(Line::raw(""));
+        lines.push(Line::from(vec![Span::styled(
+            "e edit note · g edit estimate · any other key to close",
+            Style::default()
+                .fg(Color::DarkGray)
+                .add_modifier(Modifier::ITALIC),
+        )]));
+
+        let widget = Paragraph::new(Text::from(lines))
+            .alignment(Alignment::Left)
+            .wrap(Wrap { trim: true })
+            .block(Block::bordered().title(" Task Details "));
+
+        Ui::create_modal(f, 60, 22, area, widget)
+    }
+
+    /// Full-page note preview: the Markdown body rendered with styles,
+    /// scrollable via `app.note_scroll` (clamped here against the wrapped
+    /// content height so `G` can just set `u16::MAX`).
+    pub fn show_note(app: &mut App, f: &mut Frame, area: Rect) {
+        // Both the rendered text and the title are owned, so the borrow of
+        // the current note ends here and `note_scroll` can be mutated below
+        // without cloning the body first.
+        let (text, title) = {
+            let note = Note::get_current(app);
+            let text = if note.body.trim().is_empty() {
+                Text::from(Line::from(Span::styled(
+                    "empty note — press e to write some Markdown",
+                    Style::default()
+                        .fg(Color::DarkGray)
+                        .add_modifier(Modifier::ITALIC),
+                )))
+            } else {
+                render_markdown(&note.body)
+            };
+            (text, Util::get_spaced_title(&note.title))
         };
 
-        f.render_widget(
-            Paragraph::new(help_string)
-                .wrap(Wrap { trim: true })
-                .alignment(Alignment::Center),
-            area,
-        );
+        let inner_height = area.height.saturating_sub(2) as usize;
+        let content_lines = wrapped_line_count(&text, area.width.saturating_sub(2));
+
+        app.note_scroll = app
+            .note_scroll
+            .min(content_lines.saturating_sub(inner_height) as u16);
+        let scroll = app.note_scroll;
+
+        let paragraph = Paragraph::new(text)
+            .wrap(Wrap { trim: false })
+            .block(Block::bordered().title(title));
+
+        f.render_widget(paragraph.scroll((scroll, 0)), area);
+    }
+
+    /// Full-page note editor: the `tui-textarea` created when entering
+    /// `ViewMode::EditNote`, rendered with its own block and cursor.
+    pub fn show_note_editor(app: &mut App, f: &mut Frame, area: Rect) {
+        if let Some(textarea) = app.note_textarea.as_mut() {
+            f.render_widget(&*textarea, area);
+        }
+    }
+
+    pub fn show_help_modal(app: &mut App, f: &mut Frame, area: Rect) {
+        let bindings: &[(&str, &str)] = match app.previous_view_mode {
+            ViewMode::ViewProjects => &[
+                ("↑ ↓  k j", "next/prev"),
+                ("Enter  →  l", "go to tasks"),
+                ("m", "notes"),
+                ("n", "new"),
+                ("r", "rename"),
+                ("d", "delete"),
+                ("c", "pomodoro timer"),
+                ("h", "help"),
+                ("q", "quit"),
+            ],
+            ViewMode::ViewNotes => &[
+                ("↑ ↓  k j", "next/prev"),
+                ("Enter  →  l  v", "preview"),
+                ("n", "new"),
+                ("r", "rename"),
+                ("d", "delete"),
+                ("Esc  ←", "back"),
+                ("h", "help"),
+                ("q", "quit"),
+            ],
+            ViewMode::ViewNote => &[
+                ("↑ ↓  k j", "scroll"),
+                ("PgUp  PgDn", "page up/down"),
+                ("g  G", "top/bottom"),
+                ("e", "edit (Esc saves)"),
+                ("Esc  Enter", "back"),
+                ("h", "help"),
+                ("q", "quit"),
+            ],
+            ViewMode::ViewTasks if app.board_view => &[
+                ("↑ ↓  k j", "next/prev in lane"),
+                ("← →", "switch lane"),
+                ("b", "list view"),
+                ("Esc", "back"),
+                ("Enter", "change status"),
+                ("p", "change priority"),
+                ("n", "new"),
+                ("r", "rename"),
+                ("v", "details"),
+                ("e", "note"),
+                ("v → g", "details: edit estimate"),
+                ("d", "delete"),
+                ("s", "stopwatch timer"),
+                ("c", "pomodoro timer"),
+                ("h", "help"),
+                ("q", "quit"),
+            ],
+            ViewMode::ViewTasks => &[
+                ("↑ ↓  k j", "next/prev"),
+                ("b", "board view"),
+                ("Esc  ←", "back"),
+                ("Enter", "change status"),
+                ("p", "change priority"),
+                ("n", "new"),
+                ("r", "rename"),
+                ("v", "details"),
+                ("e", "note"),
+                ("v → g", "details: edit estimate"),
+                ("d", "delete"),
+                ("t", "toggle done"),
+                ("s", "stopwatch timer"),
+                ("c", "pomodoro timer"),
+                ("h", "help"),
+                ("q", "quit"),
+            ],
+            _ => &[],
+        };
+
+        let mut lines: Vec<Line> = bindings
+            .iter()
+            .map(|(keys, desc)| {
+                Line::from(vec![
+                    Span::styled(
+                        format!("{:<16}", keys),
+                        Style::default()
+                            .fg(Color::Green)
+                            .add_modifier(Modifier::BOLD),
+                    ),
+                    Span::raw(*desc),
+                ])
+            })
+            .collect();
+
+        lines.push(Line::raw(""));
+        lines.push(Line::from(Span::styled(
+            "Press any key to close",
+            Style::default()
+                .fg(Color::DarkGray)
+                .add_modifier(Modifier::ITALIC),
+        )));
+
+        let widget = Paragraph::new(Text::from(lines))
+            .alignment(Alignment::Left)
+            .wrap(Wrap { trim: true })
+            .block(Block::bordered().title(" Help "));
+
+        // Sized with a little headroom above the longest binding list
+        Ui::create_modal(f, 42, 23, area, widget)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{
+        note::Note,
+        project::Project,
+        task::{TASK_PRIORITY_NONE, TASK_STATUS_DONE, TASK_STATUS_ON_GOING, TASK_STATUS_UP_NEXT},
+        test_utils::{make_app, make_task},
+    };
+    use ratatui::{backend::TestBackend, Terminal};
+    use tui_textarea::TextArea;
+
+    /// Rendering must not panic on any lane composition (all lanes filled,
+    /// some empty, board narrower than the content).
+    #[test]
+    fn digit_glyphs_cover_every_digit_colon_and_fallback() {
+        for c in '0'..='9' {
+            let glyph = digit_glyph(c);
+            assert_eq!(glyph.len(), 5, "glyph for {c}");
+            for row in glyph {
+                assert_eq!(row.chars().count(), 3, "glyph for {c}");
+            }
+        }
+        assert_eq!(digit_glyph(':')[0], " ");
+        assert_eq!(digit_glyph('?'), ["   ", "   ", "   ", "   ", "   "]);
+    }
+
+    #[test]
+    fn big_digit_lines_render_five_styled_rows() {
+        let lines = big_digit_lines("12:3", Color::Red);
+
+        assert_eq!(lines.len(), 5);
+        assert!(lines[0].spans[0].content.contains("█"));
+        assert_eq!(lines[0].spans[0].style.fg, Some(Color::Red));
+        assert!(lines[0].spans[0]
+            .style
+            .add_modifier
+            .contains(Modifier::BOLD));
+    }
+
+    #[test]
+    fn wrapped_line_count_estimates_wrapped_lines() {
+        let text = Text::from("abc");
+        assert_eq!(wrapped_line_count(&text, 2), 2); // ceil(3 / 2)
+        assert_eq!(wrapped_line_count(&text, 3), 1);
+        assert_eq!(wrapped_line_count(&text, 0), 3); // width clamps to 1 → one line per char
+
+        let multi = Text::from(vec![Line::raw("abcdef"), Line::raw("")]);
+        assert_eq!(wrapped_line_count(&multi, 3), 3); // 2 + 1 (empty line)
+    }
+
+    #[test]
+    fn show_board_renders_without_panicking() {
+        for (width, height) in [(120, 30), (60, 20), (30, 10), (12, 4)] {
+            let mut app = make_app(vec![Project {
+                title: "p".to_string(),
+                tasks: vec![
+                    make_task("up-next", TASK_STATUS_UP_NEXT, 1),
+                    make_task("on-going", TASK_STATUS_ON_GOING, TASK_PRIORITY_NONE),
+                    make_task("done", TASK_STATUS_DONE, TASK_PRIORITY_NONE),
+                ],
+            }]);
+            app.board_view = true;
+            app.board_sync();
+
+            let backend = TestBackend::new(width, height);
+            let mut terminal = Terminal::new(backend).unwrap();
+            terminal
+                .draw(|f| View::show_board(&mut app, f, f.size()))
+                .unwrap();
+        }
+    }
+
+    #[test]
+    fn show_board_renders_empty_lanes_without_panicking() {
+        let mut app = make_app(vec![Project {
+            title: "p".to_string(),
+            tasks: vec![make_task("only", TASK_STATUS_UP_NEXT, TASK_PRIORITY_NONE)],
+        }]);
+        app.board_view = true;
+        app.board_sync();
+
+        let backend = TestBackend::new(90, 20);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| View::show_board(&mut app, f, f.size()))
+            .unwrap();
+    }
+
+    fn note_app(body: String) -> App {
+        let mut app = make_app(vec![]);
+        app.notes = vec![Note {
+            title: "n".to_string(),
+            body,
+            created_at: None,
+            updated_at: None,
+        }];
+        app
+    }
+
+    /// The preview must render at any size and clamp an out-of-range
+    /// scroll offset (e.g. after pressing `G`) into the content.
+    #[test]
+    fn show_note_renders_without_panicking_and_clamps_scroll() {
+        for (width, height) in [(120, 30), (60, 20), (30, 10), (12, 4)] {
+            let mut app = note_app("# Title\n\nsome **bold** text\n\n- a\n- b\n".repeat(20));
+            app.note_scroll = u16::MAX;
+
+            let backend = TestBackend::new(width, height);
+            let mut terminal = Terminal::new(backend).unwrap();
+            terminal
+                .draw(|f| View::show_note(&mut app, f, f.size()))
+                .unwrap();
+
+            assert!(app.note_scroll < u16::MAX);
+        }
+    }
+
+    #[test]
+    fn show_note_renders_empty_body_hint() {
+        let mut app = note_app(String::new());
+
+        let backend = TestBackend::new(60, 20);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| View::show_note(&mut app, f, f.size()))
+            .unwrap();
+    }
+
+    #[test]
+    fn show_note_editor_renders_without_panicking() {
+        let mut app = note_app(String::new());
+        app.note_textarea = Some(TextArea::from(vec!["# hi".to_string(), "body".to_string()]));
+
+        let backend = TestBackend::new(60, 20);
+        let mut terminal = Terminal::new(backend).unwrap();
+        terminal
+            .draw(|f| View::show_note_editor(&mut app, f, f.size()))
+            .unwrap();
+    }
+
+    /// Regression test: opening help over the notes view (or the projects
+    /// view) with an empty project list used to fall into the tasks
+    /// branch of `show_items` and panic in `Project::get_current` — the
+    /// more so because ratatui clears the list selection (`select(None)`)
+    /// when rendering an empty list.
+    #[test]
+    fn show_items_with_help_over_notes_or_projects_tolerates_empty_projects() {
+        for previous in [ViewMode::ViewNotes, ViewMode::ViewProjects] {
+            let mut app = make_app(vec![]);
+            app.view_mode = ViewMode::ViewHelp;
+            app.previous_view_mode = previous;
+            app.selected_project_index.select(None);
+            let items = vec![];
+
+            let backend = TestBackend::new(80, 24);
+            let mut terminal = Terminal::new(backend).unwrap();
+            terminal
+                .draw(|f| View::show_items(&mut app, &items, f, f.size()))
+                .unwrap();
+        }
     }
 }
diff --git a/tests/cli.rs b/tests/cli.rs
new file mode 100644
index 0000000..96ae0d5
--- /dev/null
+++ b/tests/cli.rs
@@ -0,0 +1,36 @@
+//! End-to-end checks that spawn the real binary. These verify the parts of
+//! the program that cannot run inside a unit test: `--version` and
+//! `--help` print and exit successfully without starting the TUI.
+
+use std::process::Command;
+
+#[test]
+fn version_flag_prints_the_version_and_exits_successfully() {
+    let out = Command::new(env!("CARGO_BIN_EXE_basilk"))
+        .arg("--version")
+        .output()
+        .expect("failed to spawn basilk");
+
+    assert!(out.status.success(), "expected exit code 0");
+    assert_eq!(
+        String::from_utf8_lossy(&out.stdout),
+        env!("CARGO_PKG_VERSION"),
+        "--version must print exactly the package version"
+    );
+}
+
+#[test]
+fn help_flags_print_the_usage_and_exit_successfully() {
+    for flag in ["--help", "-h"] {
+        let out = Command::new(env!("CARGO_BIN_EXE_basilk"))
+            .arg(flag)
+            .output()
+            .expect("failed to spawn basilk");
+
+        assert!(out.status.success(), "{flag}: expected exit code 0");
+        let stdout = String::from_utf8_lossy(&out.stdout);
+        assert!(stdout.contains("Usage: basilk"), "{flag}: missing usage");
+        assert!(stdout.contains("--version"), "{flag}: missing --version");
+        assert!(stdout.contains("--help"), "{flag}: missing --help");
+    }
+}