Merge pull request 'Updates from Gitea: check, list and install releases from the device (#6 )' (#55 ) from gitea-updates into main

Reviewed-on: #55
CI: a branch's pushes run nothing, its pull request runs once
2026-10-06 14:29:01 +00:00 · 2026-10-06 16:17:52 +02:00 · 2026-10-06 16:16:32 +02:00 · 2026-10-06 16:06:49 +02:00 · 2026-10-06 15:51:10 +02:00 · 2026-10-06 15:20:58 +02:00
107 changed files with 8919 additions and 85 deletions
@@ -0,0 +1,109 @@
+# CI and releases (docs/milestones/R1.md).
+#   A push to main:    the host tests, with their coverage of lib/, and the README's badges
+#                      published to the branch `badges`.
+#   A pull request:    the same tests and coverage, then the release firmware and the Debug Build.
+#                      A branch's pushes run nothing by themselves: its pull request runs, once.
+#   A tag v*:          all of it, then a Gitea release with the signed Update File.
+#   Run by hand:       the release of a tag that exists already (the ones from before CI).
+#
+# The job runs in a plain Python image, as scripts/ci.sh does on a developer's machine, with the
+# toolchains in a Docker volume the runner allows (container.valid_volumes: roro9stack-pio): that
+# volume is the cache. No JavaScript actions, so the image needs no Node: the checkout is git.
+name: CI
+on:
+  push:
+    branches: [main]  # other branches are tested by their pull request: one run, not two
+    tags: ['v*']
+  pull_request:
+  workflow_dispatch:
+    inputs:
+      tag:
+        description: An existing tag to build and publish as a release
+        required: true
+
+jobs:
+  build:
+    runs-on: ubuntu
+    # A pull request from a fork would run someone else's code on our runner: not without us (Q154).
+    if: github.event_name != 'pull_request' || github.event.pull_request.head.repo.full_name == github.repository
+    container:
+      image: python:3.12-slim
+      volumes:
+        - roro9stack-pio:/pio
+    env:
+      PLATFORMIO_CORE_DIR: /pio
+      RORO_NO_DOCKER: 1
+    steps:
+      - name: Tools
+        run: |
+          apt-get update -qq
+          apt-get install -y -qq --no-install-recommends git build-essential openssl >/dev/null
+          pip install -q --no-cache-dir --root-user-action=ignore platformio gcovr
+          pio --version; df -h /pio | tail -1; ls /pio | head
+
+      - name: Check out
+        run: |
+          find . -mindepth 1 -maxdepth 1 -exec rm -rf {} +
+          git config --global --add safe.directory '*'
+          git init -q .
+          git remote add origin "${{ github.server_url }}/${{ github.repository }}.git"
+          git fetch -q --tags origin '+refs/heads/*:refs/remotes/origin/*' '+refs/pull/*/head:refs/remotes/pull/*'
+          git checkout -q --detach "${{ github.sha }}"
+          git describe --tags --always
+
+      - name: Host tests, and their coverage of lib/
+        if: github.event_name != 'workflow_dispatch'
+        run: scripts/coverage.sh
+
+      - name: The release firmware and the Debug Build
+        if: github.event_name == 'pull_request' || github.ref_type == 'tag'
+        run: scripts/ci.sh builds
+
+      # The README's badges are files on a branch of their own, replaced at each push to main.
+      - name: Publish the badges
+        if: github.event_name == 'push' && github.ref == 'refs/heads/main'
+        env:
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: |
+          rm -rf /tmp/badges && mkdir /tmp/badges
+          cp .pio/coverage/coverage.svg .pio/coverage/summary.json /tmp/badges/
+          scripts/coverage_badge.py --plain release "$(git describe --tags --abbrev=0)" /tmp/badges/release.svg
+          cd /tmp/badges
+          git init -q -b badges .
+          git add .
+          git -c user.name="roro9stack CI" -c user.email="ci@git.twis.la" commit -q -m "Coverage of ${{ github.ref_name }} at ${{ github.sha }}"
+          git push -q --force "$(echo "${{ github.server_url }}" | sed "s#://#://ci:${GITEA_TOKEN}@#")/${{ github.repository }}.git" badges
+
+      - name: Which release
+        id: release
+        run: |
+          if [ "${{ github.event_name }}" = workflow_dispatch ]; then
+            echo "tag=${{ inputs.tag }}" >> "$GITHUB_OUTPUT"
+          elif [ "${{ github.ref_type }}" = tag ]; then
+            echo "tag=${{ github.ref_name }}" >> "$GITHUB_OUTPUT"
+          fi
+
+      - name: Build and sign the release
+        if: steps.release.outputs.tag != ''
+        env:
+          OTA_SIGNING_KEY: ${{ secrets.OTA_SIGNING_KEY }}
+        run: |
+          # The sources of the tag in a clone of their own; the tools are this commit's.
+          rm -rf /tmp/release-src dist
+          git clone -q . /tmp/release-src
+          git -C /tmp/release-src checkout -q --detach "refs/tags/${{ steps.release.outputs.tag }}"
+          # The key exists as a file only while this step runs, in a container that goes with the job.
+          umask 077
+          export RORO_OTA_KEY="$(mktemp)"
+          trap 'rm -f "$RORO_OTA_KEY"' EXIT
+          printf '%s\n' "$OTA_SIGNING_KEY" > "$RORO_OTA_KEY"
+          umask 022
+          scripts/release_build.sh /tmp/release-src dist
+
+      - name: Publish the release
+        if: steps.release.outputs.tag != ''
+        env:
+          GITEA_API: ${{ github.server_url }}/api/v1
+          GITEA_REPO: ${{ github.repository }}
+          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+        run: scripts/release_publish.py dist
@@ -123,13 +123,28 @@ Data the user explicitly starts recording, such as Wi-Fi packet captures and LoR
 _Avoid_: dump, log

 **Storage Warning**:
-The Notification raised once per boot when the SD card passes 80% full. Selecting it opens Storage Clean-up.
+The Notification raised once per boot when the SD card passes 80% full. It points at the Storage App, where Maintenance holds Storage Clean-up.

 **Storage Clean-up**:
-The screen where the user deletes old Logs and Captures by category and age, with a preview of the space freed. Notes are never offered for deletion.
+The screen where the user deletes old Logs and Captures by category and age, with a preview of the space freed. Notes are never offered for deletion. It lives in the Storage App, under Maintenance.
+
+**Note**:
+A plain text file in `/notes`, written on the device in the Notes App. Listed by its first line. Saved without being asked; never offered by Storage Clean-up.
+_Avoid_: memo, document
+
+**Storage App**:
+The App that browses the SD card: folders and files, a clipboard for one item at a time (copy, cut, paste), rename, delete, new folder, and a viewer for each kind of file the firmware writes. The top-level folders, `/gemini/cache` and files being written are read-only.
+_Avoid_: file manager, Files, explorer
+
+**Maintenance**:
+The part of the Storage App that deletes in bulk: the card's usage, Storage Clean-up and erasing the card. Reached through a warning.
+_Avoid_: Settings > Storage

 **Firmware Update**:
-Installing a new firmware image without a USB cable: pushed over Wi-Fi from the developer's PC, or read from the SD card.
+Installing a new firmware image without a USB cable: pushed over Wi-Fi from the developer's PC, read from the SD card, or downloaded from the project's Gitea **Release**.
+
+**Release**:
+A tag `v*` on the project's Gitea with a signed **Update File**, a factory image for USB, the ELF to decode crashes and checksums, built and published by CI. The device reads them to look for updates. Debug Builds aren't published.
 _Avoid_: flash, upgrade (alone)

 **Update File**:
@@ -1,5 +1,7 @@
 # roro9stack

+[![CI](https://git.twis.la/twisla/roro9stack/actions/workflows/ci.yml/badge.svg?branch=main)](https://git.twis.la/twisla/roro9stack/actions?workflow=ci.yml) [![Coverage of lib/ by the host tests](https://git.twis.la/twisla/roro9stack/raw/branch/badges/coverage.svg)](#build-and-test-local-ci) [![Latest release](https://git.twis.la/twisla/roro9stack/raw/branch/badges/release.svg)](https://git.twis.la/twisla/roro9stack/releases/latest)
+
 A multi-app firmware for the **M5Stack Cardputer ADV** with the **Cap LoRa-1262**. It's a Meshtastic-compatible mesh messenger, plus Wi-Fi tools, IRC, GNSS and more. Licensed GPL-3.0.

 - Domain language: [CONTEXT.md](CONTEXT.md)
@@ -18,8 +20,23 @@ scripts/ci.sh

 This runs the host-side unit tests (`test/`, `native` environment), then builds the firmware. The output is `.pio/build/cardputer-adv/firmware.factory.bin`.

+`scripts/coverage.sh` runs the same tests with coverage counters and writes a line-by-line report to `.pio/coverage/index.html`. The badge above is its figure for `main`: the share of the lines of `lib/` that the host tests run. `lib/` is the logic that compiles on a PC; `lib/SD` (the card's driver) and `src/` (the Apps, the Services, everything that needs the device) have no host tests and aren't in that figure.
+
 The framework is rebuilt with the TLS settings in `platformio.ini` (`custom_sdkconfig`, ADR 0006), so the first build after a fresh checkout takes about 4 minutes; later builds take under a minute.

+## CI and releases
+
+Gitea Actions (`.gitea/workflows/ci.yml`, docs/milestones/R1.md) runs the host tests on every push to `main`, and on a pull request also builds the release firmware and the Debug Build: changes reach `main` through pull requests. Pushing a tag `v*` runs all of it and publishes a release on Gitea with:
+
+- `roro9stack-<version>.ota`, the signed Update File;
+- `roro9stack-<version>-factory.bin`, the whole flash image for a first install over USB;
+- `roro9stack-<version>.elf.gz`, to decode crash reports from that build;
+- `SHA256SUMS`.
+
+CI signs with the project's key, held as a repository secret (ADR 0008). Debug Builds are built but never published: each carries its builder's Debug Console token.
+
+`scripts/ota_verify.py <file.ota>` checks an Update File on a PC the way a device does. `scripts/release_build.sh` and `scripts/release_publish.py` are what the workflow runs; they work the same by hand.
+
 ## Flash

 1. Connect the Cardputer by USB-C.
@@ -52,7 +69,21 @@ The device shows the push address in **Settings → Firmware**. It installs a co

 To install from the SD card instead, copy the `.ota` file from `.pio/build/cardputer-adv/` into `/updates` on the card, then use **Settings → Firmware**. With the Cardputer on USB, the card can stay in: `scripts/sd_put.sh <file.ota>` sends it over the serial console into `/updates` (about 30 s for 1.6 MB, checked with SHA-256 before it's renamed into place; `SD_PUT_DEBUG=1` shows the console while it runs).

-**The private key** lives in `~/.config/roro9stack/ota-key.pem` and must never be committed. If it's lost, generate a new pair and flash once over USB.
+**The private key** lives in `~/.config/roro9stack/ota-key.pem` and must never be committed. If it's lost, generate a new pair and flash once over USB. (CI signs releases with a copy kept as a repository secret, ADR 0008.)
+
+### Updates from Gitea
+
+With no PC and no card, the device can install the project's releases itself (docs/milestones/R1.md). In **Settings → Firmware**:
+
+- **Latest release** checks the server (Enter, or `c`) and says `v0.11.0 (new)` or `(current)`. Enter again opens the release: its version, date, size and the tag's message, with **Install** when it's newer. The download goes straight into the inactive slot, so no card is needed; the signature is checked after the first 160 bytes, before anything is written, and the image's hash at the end. The new firmware then runs on Probation as for any update.
+- **Older releases** lists the last ten, newest first. Opening an older one offers to go back to it, with a different question.
+- **Settings → Check for updates** (on by default): once a day, with Wi-Fi up and the clock set, the device looks at the latest release and says `v0.11.0 is out: see Settings > Firmware`, once per version. It installs nothing by itself, and doesn't announce a version that already failed and rolled back on this device.
+
+The connection is checked against the two ISRG roots Let's Encrypt chains end in (ADR 0009), not the usual bundle of about 130 authorities. Whatever the connection, the Update File's own signature is what decides what gets installed.
+
+**IRC steps aside.** A secure connection takes about 52 KB of memory at its peak, and IRC's own takes 40 KB of the 107 KB there is. A check or an install you ask for makes IRC disconnect for the few seconds it takes and reconnect afterwards. The daily check never does that: with IRC connected it waits for a moment when IRC isn't, so while IRC stays connected for days it doesn't run, and **Latest release** is the way to check.
+
+**A Debug Build** shows the latest release but doesn't install it: releases have no Debug Console (they aren't built with one, so that nobody's console token is published), and installing one would take it away. A Debug Build is updated from the PC with `scripts/flash.sh --debug --ota`.

 ## Networks without DHCP

@@ -60,6 +91,18 @@ Each Saved Network gets its address automatically (DHCP) or has a Fixed one (doc

 "DNS and NTP" on the same screen holds two DNS servers (9.9.9.9 and 1.1.1.1 by default), used on Fixed networks, or on every network with "Always use my DNS"; and two NTP servers (pool.ntp.org and time.cloudflare.com), used after any the network's DHCP offers. Enter on "Status" shows what's in use and where each value came from.

+## System
+
+The System App (docs/milestones/S1.md) shows what the device is doing, live and read-only, in any build. Tab moves between five views:
+
+- **Overview:** each core's load, free memory, network traffic, battery, uptime and chip temperature, and both cores' load over the last two minutes.
+- **Tasks:** every FreeRTOS task with its core, its share of a core over the last second, and the least stack it ever had left (in the warning colour under 512 bytes). `s` sorts by share, stack or name.
+- **Memory:** free heap, the lowest since boot and the largest free block, with two minutes of free heap drawn against the three memory floors (55, 40 and 20 KB).
+- **Network:** the connection, then for IRC, Gemini, the Debug Console and Firmware Updates the bytes read and written since boot and what's moving now. For TLS connections these are the bytes the service sees, without the encryption overhead.
+- **System:** what `info` prints, plus the battery, the SD card with its write faults, the radio and the GNSS receiver.
+
+It samples once a second and keeps its history only while it's open.
+
 ## Gemini

 The Gemini App browses Geminispace (docs/milestones/G1.md): Tab and Shift+Tab pick a link, Enter follows it, Back returns (to where the page was scrolled), Space pages down, `g` types an address. Certificates are trusted on first use; a changed one stops the page and asks.
@@ -68,7 +111,42 @@ On a page, `b` bookmarks it, `s` saves it to the SD card to read offline (a non-

 ## LoRa Scanner

-The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **never transmits**. The Sniffer lists what it hears, newest first: time, RSSI, SNR, and for Meshtastic packets the sender and receiver (their last 4 hex digits) and hops. Enter shows a packet's details: the Meshtastic header (which is never encrypted) and a hex dump. `p` picks one of the 7 Meshtastic presets allowed in EU868 (LongFast by default), `c` starts or stops a Capture: a pcap file with LoRaTap headers in `/captures/lora/`, for Wireshark. A Capture keeps recording with the App closed; otherwise the radio sleeps when the App isn't open. Tab switches to **Sweep**: the signal strength across 863–870 MHz in 100 kHz steps, as bars with peak hold and a waterfall, with the Sniffer's frequency marked; the Sniffer is paused meanwhile and picks up where it was. The Status Bar shows `L` while the radio listens (bright for a moment on each packet), `SW` while sweeping, and `CAP` while capturing.
+The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **never transmits**. The Sniffer lists what it hears, newest first: time, RSSI, SNR, and for Meshtastic packets the sender and receiver (their last 4 hex digits) and hops. Enter shows a packet's details: the Meshtastic header (which is never encrypted) and a hex dump. `p` picks one of the 7 Meshtastic presets allowed in EU868 (LongFast by default), `c` starts or stops a Capture: a pcap file with LoRaTap headers in `/captures/lora/`, for Wireshark. A Capture keeps recording with the App closed; otherwise the radio sleeps when the App isn't open. Tab switches to **Sweep**: the signal strength across 863–870 MHz in 100 kHz steps, as bars with peak hold and a waterfall, with the Sniffer's frequency marked; the Sniffer is paused meanwhile and picks up where it was. The GNSS receiver on the same Cap raises the radio's noise floor by 8 dB while it runs: Settings > "Pause GNSS for LoRa" (off by default) puts it in standby while the radio listens, except during a Track. The Status Bar shows `L` while the radio listens (bright for a moment on each packet), `SW` while sweeping, and `CAP` while capturing.
+
+## Storage
+
+The Storage App (docs/milestones/F1.md) shows what's on the SD card: each folder's entries with their size and date, folders first. Enter opens a folder, Back goes up; `s` sorts by name, date or size. It works on one item at a time, with a clipboard:
+
+| Key | Does |
+|---|---|
+| `c` / `x` | Copies or cuts the selected file or folder; the footer shows what `v` would paste |
+| `v` | Pastes it into the folder shown. A copy next to its original is named `name (2).txt`; anything in the way is asked about first |
+| `r` | Renames |
+| `d` | Deletes, after saying what's inside: "Delete saved and its 42 files (1.2 MB)?" |
+| `n` | Makes a folder |
+| `i` | Details: type, exact size, date, and why an item is read-only if it is |
+
+A copy runs in the background of the card (about 400 KB a second) in short turns, so Logs and Captures keep being written; it shows its progress, Back cancels it and takes back what was copied, and each file's size is checked afterwards. Three things can't be changed: the top-level folders the firmware keeps its files in (what's inside them can), `/gemini/cache`, and any file being written right now (today's IRC Logs, a Track or a Capture being recorded). The App says why when it refuses. A folder with more than 256 entries shows the first 256 by name and says so.
+
+Enter on a file opens it by type; Tab switches to the same file as a hex dump or as text:
+
+- **Text** (`.txt`, `.log`, `.gmi`, `.csv`, and anything that looks like text): only the screen's worth is read from the card, so a file of any size opens at once. Logs open at the end. Up and Down move a line, Left and Right a page, `t` and `b` go to the top and the end, `e` edits it (up to 16 KB, see Notes).
+- **Captures** (`.pcap`): the packets as the LoRa Scanner lists them; Enter shows one with its Meshtastic header and bytes.
+- **Tracks** (`.gpx`): the number of points, the start, the duration and the distance.
+- **Update Files** (`.ota`): the version, and whether the file would install: it's checked as an install checks it (signature and contents) without writing anything. Enter then installs it.
+- **Anything else:** a hex dump.
+
+At the top of the card the last row, **Maintenance** (also `m`), holds the card's usage, Storage Clean-up and "Erase SD card", behind a warning: those delete for good. It replaces Settings > Storage.
+
+## Notes
+
+The Notes App (docs/milestones/F1.md) keeps plain text notes in `/notes` on the SD card. The list shows each note's first line and its date, newest first; `s` switches to by file name. `n` starts a note, Enter opens one, `r` renames its file, `d` deletes it after asking.
+
+In the editor, type. Enter starts a line, Del deletes backwards, Fn with the arrows moves the cursor through the wrapped text, Ctrl+A and Ctrl+E go to the start and the end of the line, Tab types two spaces, and the Compose Key gives accents as everywhere. **There's no save key:** the note is written five seconds after the last key, on Back, on leaving the App, when the screen turns off and before the device powers off. The top line says "typing" or "saved". Each save writes a temporary file and then puts it in the note's place, so a power cut costs a few seconds of typing and never the note; if a save was cut short, opening the note offers its copy back.
+
+A new note has no file until something is typed; its file is then named after its first line (`shopping-list.txt`), or `note-<date>-<time>.txt`.
+
+A note holds up to 16 KB while it's edited. A bigger text file opens read-only in the Storage App (editing any size is issue #47). The Storage App's text viewer has `e` to edit a file with the same editor, anywhere on the card, unless the file is read-only.

 ## Development aids

@@ -86,6 +164,7 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve
 | `log <text>` | Appends a line to a test IRC Log (`/irc/dev/#test/<date>.log`) |
 | `sd card` | What the SD card says it is: type, size, and its identity register (maker, name, revision, serial, date) |
 | `sd list` | Lists the files of each Storage Clean-up category |
+| `sd fill <folder> <count>` | Debug Builds: makes that many small files in a folder, to test a crowded one |
 | `cat <path>` | Prints the first ~1.2 KB of a file on the SD card |
 | `irc start` | Starts the IRC Service (normally done by opening the IRC App) |
 | `irc stop` | Stops it, as `/quit` does: QUIT if connected, no more retries, and the App stays disconnected until you type |
@@ -95,20 +174,27 @@ The LoRa Scanner (docs/milestones/M3.md) listens with the Cap's radio and **neve
 | `irc dump` | Prints IRC status, memory, and the last lines of each Buffer |
 | `wifi status` | Prints Wi-Fi state, network, signal, clock and free heap, then the address, gateway, DNS and NTP servers in use and where each came from |
 | `info` | Firmware, uptime, last start reason, memory, Wi-Fi, the SD card and its write faults since boot, and both app slots with their versions and OTA states |
-| `tasks` | FreeRTOS tasks: state, priority, lowest free stack, CPU share |
+| `tasks` | FreeRTOS tasks over the next second: state, priority, lowest free stack, share of a core, each core's load, and how many passes the main loop made |
+| `net` | Bytes each network service has read and written since boot |
 | `reboot` / `boot other` | Restart, or restart into the other app slot (a manual Rollback) |
 | `log level <0-5>` | ESP-IDF log level |
-| `ls [folder]` / `rm <path>` | Lists a folder of the SD card, or deletes a file |
+| `ls [folder]` / `du <path>` | Lists a folder of the SD card with sizes and dates, or counts the files and bytes under a path |
+| `cp [-f] <from> <to>` / `mv [-f] <from> <to>` / `rm <path>` / `mkdir <path>` / `cancel` | What the Storage App does, with its rules: copy (folders too), move or rename, delete (a folder with what's in it), new folder. `-f` replaces a file that's in the way; a tab separates paths that hold spaces; `cancel` stops a copy or a delete |
 | `install <path>` | Update from SD with that `.ota` file, as Settings → Firmware does |
+| `update check` / `update list` / `update status` / `update install <tag>` | The project's releases on Gitea: look at the latest, list the last ten, say what's known, or download and install one (not on a Debug Build) |
+| `update pretend <version>` / `update probe <host>` / `update damage cut\|flip <n>` / `update daily` | Debug Builds: pretend to run another version (so a release counts as an update), see whether a server's certificate is accepted, cut or damage the next download, run the daily check again |
 | `lora probe` | Finds the radio: chip, oscillator, antenna switch, DIO1 interrupt, noise floor |
 | `lora status` | Radio settings, who's listening, packet and error counters, noise floor, task stack |
 | `lora rx on` / `lora rx off` | Listens and prints each packet on the console |
 | `lora preset <name>` / `lora custom <MHz> <BW kHz> <SF> <CR> <sync hex> [preamble]` | Receive settings: a Meshtastic preset, or anything else (`lora custom 868.1 125 7 5 34 8` for LoRaWAN) |
 | `lora capture start` / `lora capture stop` | A LoRa Capture, as `c` in the App |
 | `lora sweep on [from MHz] [to MHz] [step kHz]` / `lora sweep off` / `lora sweep dump` | Sweep a band (863 870 100 by default), with a summary every 2 s (floor, strongest, peaks), or print the latest pass |
+| `gnss quiet on` / `gnss quiet off` | The "Pause GNSS for LoRa" setting |
+| `lora noise test [gnss\|quiet]` / `lora noise report` | Debug Builds: Sweep under one changed condition at a time to find what raises the noise floor (Wi-Fi goes off for a few seconds); then the result |
 | `lora inject <hex> [rssi] [snr]` | Debug Builds: a packet into the Scanner as if received (nothing is sent) |
 | `crash` | The last crash: which firmware, why, task, PC and backtrace (from the core dump in flash) |
 | `coredump erase` | Forgets the core dump |
+| `loop spin on` / `loop spin off` | Debug Builds: make the main loop spin without resting, to compare load and radio noise |
 | `crash abort` / `crash wdt` | Debug Builds: crash on purpose, or hang the main loop until the watchdog fires |
 | `help` | Lists the commands |

@@ -5,7 +5,7 @@ RUN apt-get update \
 && apt-get install -y --no-install-recommends git build-essential \
 && rm -rf /var/lib/apt/lists/*

-RUN pip install --no-cache-dir platformio
+RUN pip install --no-cache-dir platformio gcovr

 # Toolchains and libraries are cached in a named volume mounted here.
 RUN mkdir -p /pio && chmod 777 /pio
@@ -0,0 +1,17 @@
+# CI signs releases with the project's key
+
+A tag `v*` is built, signed and published by Gitea Actions with nobody at a keyboard. The signing key of ADR 0003 is therefore held twice: in `~/.config/roro9stack/ota-key.pem` on the development machine, as before, and as the repository secret `OTA_SIGNING_KEY`, which the release step writes to a file for as long as it runs.
+
+We chose this over signing by hand after CI has built (a command per release, the key in one place), and over a second key for CI that the firmware would also trust. A release that needs a manual step isn't made on the day it's ready, and issue #6, the device installing releases by itself, needs releases that are always there and always signed.
+
+## What it costs
+
+- **Whoever can run a workflow in this repository can sign firmware every device accepts.** That means: anyone who can push to it, the runner's host and whoever administers it, and the Gitea instance with its database, where the secret is stored. Before, it took the development machine.
+- The runner executes jobs **on its own host**, not in a container, as a user who can use Docker. A workflow is not confined.
+- Pull requests from forks must never run with this secret. Gitea doesn't pass secrets to them; the workflow also only runs on pushes and by hand.
+
+## What limits it
+
+- The release step checks the signed file against the public key in the sources it built (`scripts/ota_verify.py`): a wrong or replaced secret stops the release instead of publishing a file no device takes.
+- ADR 0003's way out stays: a firmware release can carry a new public key. If the secret is ever in doubt, make a new pair, ship it in a release signed with the old key, and replace the secret.
+- A device still only installs what it's told to (until #6), keeps a new image on Probation, and rolls back one that doesn't hold.
@@ -0,0 +1,22 @@
+# The device trusts the two ISRG roots for what it fetches
+
+The firmware talks to the project's Gitea over HTTPS (issue #6, and #4 after it). A TLS client has to decide whose certificates it believes. Three ways were possible:
+
+- **The framework's bundle**, about 130 certificate authorities (about 60 KB of flash). Any of them could vouch for `git.twis.la`.
+- **Pin the server's certificate**, as the Gemini App does for capsules. The server's certificate is replaced every few months, so a pin would ask the question again at every renewal.
+- **Carry the roots the server's chain ends in:** `ISRG Root X1` (RSA 4096) and `ISRG Root X2` (ECDSA P-384), the Let's Encrypt roots, about 2.7 KB of flash (`src/platform/ca_roots.h`).
+
+We chose the third. The chain and the name are checked by mbedTLS during the handshake. It trusts one organisation's two roots, valid until 2035 and 2040, and a renewal changes nothing.
+
+## What it costs
+
+- **If the server moves to another CA, the device can no longer reach it**, and the next firmware, carrying that CA's root, has to come from the PC or the SD card. Both still work; they don't use TLS.
+- The roots are public data checked against the published fingerprints (listed in the file), refreshed by hand if Let's Encrypt ever changes them.
+
+## What it doesn't change
+
+The Update File's own signature (ADR 0003) is what decides what gets installed. A hijacked connection could hide a release, or serve an older signed one, but never make the device install firmware that isn't ours. The TLS check matters more for #4, where a token will travel over it.
+
+## Measured while building it
+
+A TLS connection to this server peaks at about 52 KB of heap, **the same whether the certificate is checked or not**, so skipping the check would have saved nothing. The cost is the connection itself (record buffers and handshake), not the trust decision.
@@ -0,0 +1,161 @@
+# F1 — Files and Notes
+
+**Status:** in progress. The Storage App (issue #3) shipped as **v0.9.0** on 2026-10-06. Notes (#19) shipped as **v0.10.0** the same day. The card as a USB drive (#1) comes after.
+
+**Goal:** get at what's on the SD card from the device itself: browse it, look inside the files the firmware writes, copy, move, rename and delete, and keep notes. A side milestone, like G1 and S1; Files and Notes were M3's original second half (Q30, Q89).
+
+## The Storage App (issue #3)
+
+Until now the card could be looked at only through the Debug Console (`ls`, `get`, `put`), and Settings > Storage could only delete whole categories by age.
+
+**On the card today:** six top-level folders, `irc`, `wifi`, `updates`, `gnss`, `gemini` and `captures`. No `notes` yet; settings are in flash, not on the card.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q128 | An App of its own, **Storage**, in the Launcher. **Settings > Storage goes away:** its usage figures, Storage Clean-up and "Erase SD card" move into the App, under **Maintenance**, behind a warning that these delete things for good. |
+| Q129 | A row shows the name, then the size or "folder", then the date modified. Folders first, then by name; `s` cycles the sort (name, date, size). The top line shows the path and the card's free space. |
+| Q130 | Nothing is hidden. **Read-only:** `/gemini/cache`; any file the firmware has open right now (today's IRC log, a Track or Capture being recorded, a file being received); and the top-level folders themselves, which can't be renamed or deleted though their contents can. **Everything else, the user's own data included, can be renamed, moved or deleted**, always after a confirmation. |
+| Q131 | One item at a time, with a clipboard: Enter opens; Back goes up, and leaves the App at the top; `c` copy, `x` cut, `v` paste into the current folder; `r` rename; `d` delete; `n` new folder; `i` details. |
+| Q132 | Copy, move and delete work on folders too, recursively. The confirmation says what's inside: "Delete *saved* and its 42 files?". |
+| Q133 | A copy is a job on the storage task in 4 KB pieces, with a progress Toast; Back cancels it. It checks free space first and asks before replacing anything. **Afterwards the sizes are compared**, not the contents: the driver is trusted since v0.6.1 (ADR 0007). A move within the card is a rename. |
+| Q134 | Viewers by type. **Text** (`.txt`, `.log`, `.gmi`, `.csv`, `.gpx`, and anything that looks like text): read from the card as you scroll, so size doesn't matter; logs open at the end. **`.pcap`:** the LoRa Scanner's packet list. **`.gpx`:** a summary (start, duration, points, distance), Tab for the text. **`.ota`:** version, size, whether the signature is valid; Enter installs through Update from SD. **Anything else:** a hex dump. |
+| Q135 | No editing: that comes with Notes (#19). |
+| Q136 | A listing holds **up to 256 entries**, packed, about 10 KB; a bigger folder shows the first 256 by name and says how many more there are. The App refuses to open below the memory floors (Q86). |
+| Q137 | **The Clock also sets the system time**, so files are dated correctly with GNSS alone and not only after NTP. A file dated before 2020 shows "-". |
+| Q138 | Console: `cp`, `mv` and `mkdir`, next to `ls` and `rm`. |
+| Q139 | Left out, each with its issue: selecting several items (#41), finding files by name (#42), opening a `.gmi` in the Gemini App (#43), a table view for `.csv` (#44), images (#45). |
+| Q140 | Ships as **v0.9.0** when done and checked. |
+
+### Done when
+
+- The Storage App lists any folder of the card with sizes and dates, sorted three ways, and says so when a folder has more than 256 entries.
+- A file can be copied, moved, renamed and deleted, and a folder too; a new folder can be made. Each destructive action asks first; a copy shows progress and can be cancelled.
+- The read-only rules of Q130 hold, with a reason given when something is refused.
+- Each viewer of Q134 opens its type, and a 1 MB text file scrolls without loading whole.
+- Maintenance shows the card's usage and does what Settings > Storage did, behind its warning; Settings no longer has a Storage row; the Storage Warning points at the Storage App.
+- A file written with only a GNSS Fix (no Wi-Fi) is dated correctly.
+- Free heap stays above the floors with the App open, Wi-Fi and IRC on TLS.
+
+### Work breakdown
+
+1. **Model** (host-tested): paths and names, the read-only rules, the packed listing and its sorts, file types, sizes and dates for display, the GPX summary.
+2. **Card operations:** listing a folder, copy, move, delete (recursive, counted), new folder, as storage jobs with progress and cancel; `cp`, `mv`, `mkdir`; the Clock sets the system time.
+3. **The App:** browsing, the clipboard, dialogs, details.
+4. **Maintenance:** usage, Clean-up and Erase moved in from Settings, with the warning.
+5. **Viewers:** text, hex, `.pcap`, `.gpx`, `.ota`.
+6. **Checks on the device**, recorded here.
+
+### As built
+
+- **`FileOps`** (`src/services/file_ops`) does the card's work for the App and for the console alike: list, count, copy, move, delete, new folder. One operation at a time on the storage task, **in turns of about 150 ms** that queue themselves again, so Log lines and a Capture are written in between. The rules of Q130 are checked there, whoever asks.
+- **A listing reads the folder straight from FatFs.** Through the Arduino `File`, every entry was looked up by name again for its size and again for its date: 329 entries took over two seconds. One pass now, and it's there before the screen has redrawn. Counting, copying and deleting still walk with `File`; they show progress and can be stopped.
+- **A copy shows its progress in a box in the App**, not a Toast (Q133): it has a bar and says Back cancels. A cancelled or failed copy deletes what it had written. The copy gets today's date, like `cp`.
+- **The viewers** (`src/apps/file_viewer`, models in `lib/files`): text through `TextPager`, which reads about a kilobyte around the screen and wraps at spaces, 38 columns; going back a line wraps the paragraph before again, so a file reads the same in both directions. A `.pcap`, a `.gpx` and an `.ota` are read through once by a storage job, in the same 150 ms turns. An Update File is fed to the installer's own parser with a sink that writes nothing, so "would it install" is the same answer an install gives.
+- **Tab** in a viewer shows the same file as hex, or as text (not in Q134).
+- **Maintenance** is the last row at the top of the card, and `m` anywhere in the App. It's the old Settings > Storage page behind a dialog.
+- **The Storage Warning** was only ever a Toast; "selecting it opens Storage Clean-up" (CONTEXT.md) was never built. It now reads "SD card over 80% full: see Storage".
+- **Console:** `cp`, `mv`, `mkdir` (Q138), and `rm` and `du` through the same code, so `rm` now takes folders and follows the rules; `ls` shows dates. Debug Builds: `sd fill <folder> <count>` makes test files.
+
+### Checks on the device (2026-10-06, v0.8.1-2 Debug Build)
+
+All in a scratch folder, `/f1test`, removed afterwards.
+
+| Check | Result |
+|---|---|
+| Host tests | 424 pass (411 before the viewers' models) |
+| Browsing | Folders first, sizes and dates, the three sorts; a 300-file and a 329-file folder show "first 256 of 300" and "of 329" |
+| New folder, rename, copy, cut and paste, delete | Each works on a file and on a folder; a copy next to its original is named `(2)`; a name in the way asks "Replace it?" |
+| A folder of 11 files, 8.4 MB, copied | 19.4 s, 435 KB/s, the bar moving; two Log lines queued meanwhile were written |
+| The same copy cancelled at 1.8 MB | "Cancelled: nothing was copied", and nothing was left behind |
+| Delete | 341 files in 9.7 s; the dialog had counted them first |
+| Read-only rules | `/irc`, `/gnss` (top-level folders), `/`, `/gemini/cache` and a folder made inside it, a folder into itself, a name with `:`; a Capture being recorded and the folder holding it; a folder under `/irc` while IRC runs. Each refused with its reason; the Capture could still be copied |
+| Text | A 1 MB log opens at its last line at once; top, pages, lines; a file without an extension that looks like text opens as text |
+| Hex | A 5 KB binary file; Tab from any other viewer |
+| `.pcap` | A LoRa Capture: 3 packets as the Scanner lists them, Enter shows the Meshtastic header and bytes |
+| `.gpx` | 400 points: start, 33 min 15 s, 4.68 km; Tab shows the text |
+| `.ota` | A signed file: version, "intact", "older than what's running", Enter asks to install (not confirmed). A tampered one: "image corrupted (hash mismatch)" |
+| Maintenance | The warning, then usage, Clean-up's categories and Erase (not run) |
+| Date with GNSS only | NTP pointed at an address that doesn't answer, restart: the Clock came from the Fix, and a folder made then is dated 2026-10-06 08:39. A Track from the day before, written the same way by v0.8.1, shows "-" |
+| Memory | IRC connected, the App open on 256 entries: 61 KB free (70 KB before opening). Lowest since boot 29.7 KB, during IRC's TLS handshake |
+| Stacks | `storage` 3.1 KB free of 6 KB at worst, `loopTask` 1.5 KB |
+
+**Not checked by hand:** how the keys feel on the device itself; everything above was driven through the Debug Console's `key` command and screenshots.
+
+**One slip during the checks:** a scripted key sequence ran in the wrong folder and renamed `/gemini/saved` to `saved2`, then copied it to the top of the card. Both were put right at once (renamed back, the copy deleted; 7 files, 53,798 bytes, as before).
+
+**Found on the way:** a panic at Wi-Fi join, there since v0.7.0 (SNTP started twice, issue #46). Fixed in v0.9.0.
+
+## Notes (issue #19)
+
+Plain text notes on the SD card, written on the device. Q30 settled the base: `.txt` files in `/notes`, created, edited and deleted from the device, never offered by Storage Clean-up.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q141 | A **Notes** App in the Launcher. One row per note: its first line as the title, then the date. Newest first; `s` switches to by name. `n` new, Enter opens, `d` deletes after a confirmation, `r` renames the file. |
+| Q142 | A new note's file name is never typed: it comes from the first line when the note is first saved (`shopping-list.txt`), or `note-20261006-0919.txt` if that line is empty. It doesn't change afterwards unless the note is renamed. |
+| Q143 | **Autosave, no "discard changes?" prompt:** five seconds after the last key, on leaving the note or the App, and when the screen turns off. A save writes a temporary file and renames it over the note, so a power cut loses the last few seconds at most. A temporary file left behind is offered back at the next open. |
+| Q144 | The whole note is in memory while it's edited, up to **16 KB**. A bigger text file opens read-only in the Storage App's viewer. The App refuses to open below the memory floors (Q86). **Editing files of any size must come in a later release: issue #47.** |
+| Q145 | The editor wraps at spaces, 38 columns by 8 rows, with a line for the name and the state. Enter is a new line, Del deletes backwards, Fn+arrows move (the Text Entry rule), Ctrl+A and Ctrl+E go to the start and the end of the line, Tab types two spaces, Back saves and returns. The Compose Key works as elsewhere. |
+| Q146 | The Storage App's text viewer gets `e`: edit this file with the same editor, for a text file up to 16 KB that isn't read-only. That lifts Q135 without Apps opening each other (#43 stays). |
+| Q147 | The list is flat: the files directly in `/notes`. Sub-folders are reached through the Storage App. |
+| Q148 | UTF-8, LF line ends; a file with CRLF is saved back with LF. Characters the font lacks are kept on save. |
+| Q149 | Left out, each with its issue: editing files of any size (#47), searching inside notes (#48), undo (#49), selecting and copying text (#50). |
+| Q150 | Ships as **v0.10.0** when built and checked on the device. |
+
+### Done when
+
+- A note can be started, typed with accents, left and found again in the list under its first line; renamed; deleted after a confirmation.
+- What's typed is on the card five seconds after the last key, and after Back, Home, or the screen turning off, without a prompt.
+- Pulling the power while typing loses a few seconds at most, and the note is never left empty or half-written.
+- The cursor moves by character and by line through wrapped text, and the screen follows it; a 16 KB note edits without lag.
+- A note at 16 KB refuses more text and says so; a bigger file opens read-only.
+- `e` in the Storage App's text viewer edits a file; a read-only one is refused with its reason.
+- Free heap stays above the floors with a 16 KB note open and IRC connected.
+
+### Work breakdown
+
+1. **Model** (host-tested): the text buffer with its cursor, wrapping and scrolling; file names from first lines.
+2. **The editor on the device:** loading, drawing, keys, autosave through a temporary file, recovery.
+3. **The Notes App:** the list with titles, new, rename, delete.
+4. **`e` in the Storage App.**
+5. **Checks on the device**, recorded here.
+
+### As built
+
+- **`NoteText`** (`lib/notes`, host-tested) is the text, its cursor and the screen around it. A line owns the space or the newline it ends with, so every byte is on exactly one line and the cursor has one place for each. **No index of lines is kept:** a note of newlines alone would need twice its own size for one. Where a line starts is worked out from the start of its paragraph.
+- **One buffer, 16 KB, for as long as the editor is open.** It's reserved when the note is opened, the file is read straight into it, and typing never makes it grow. On this device a failed allocation is an abort, and with IRC connected the largest free block is about 31 KB whatever the total says: the first version read the file into one string and copied it into another, and opening a full note with IRC connected restarted the device. The editor now also refuses to open without a free block of 24 KB.
+- **`NoteEditor`** (`src/apps/note_editor`) is shared by the Notes App and the Storage App's `e`. A save runs on the storage task while the main loop waits for it: no second copy of the note, and at 16 KB the wait is a fraction of a second at a moment when nobody has typed for five.
+- **A save** writes `<note>.tmp`, checks its size, deletes the note and renames the temporary file (FAT can't rename onto a file). A cut between the last two steps leaves only the `.tmp`: the Notes list puts such a file back under its name. A `.tmp` next to its note is an unfinished save: opening the note offers it.
+- **Titles** in the list are read from the card for the eight rows on screen, when the list moves.
+- **Before powering off**, the firmware now leaves the foreground App (`PowerService::beforePowerOff`), which makes the editor save.
+- Shift or Alt with Fn+Up and Fn+Down moves a page (not in Q145).
+
+### Found on the way
+
+- **The screen could go "off" for one tick after a key sent through the Debug Console**, and the next key was then swallowed as a wake-up: the `key` command stamps the power timer from `millis()`, the power tick compares with its pass's older time, and the unsigned difference read as 49 days idle. The same shape as #46. Fixed in `PowerPolicy::update` with a test. Keys from the keyboard were never affected. It explains remote keys "lost" in earlier sessions.
+- **`scripts/rdbg.py` held back piped lines** written while it was still connecting, until the next line came (a buffered `readline()` behind `select()`). Fixed.
+
+### Checks on the device (2026-10-06, Debug Build of branch `notes`)
+
+Test notes were made in `/notes` and removed afterwards; the folder is left, empty.
+
+| Check | Result |
+|---|---|
+| Host tests | 439 pass |
+| A first note | "No notes yet", `n`, typed three lines: the top line says "typing", then "saved" five seconds after the last key, under `shopping-list.txt`. 63 keys in a row all arrived |
+| Leaving | Back saves and returns to the list, which shows the note under its first line. Home in the middle of a new note saved it as `ideas.txt` |
+| The cursor | Down, Right, an insertion in the middle of a line; the screen scrolls through a note of about 230 lines |
+| A power cut | Typed, waited seven seconds, typed more and restarted the device at once (`reset`): the note has what was saved, whole, and not the last keys |
+| An unfinished save | A `.tmp` next to its note: "Unsaved copy... Keep the note / Use the copy"; using it brings its text back and saves it. A `.tmp` alone was put back under its name when the list opened |
+| 16 KB | A note of exactly 16,384 bytes opens and scrolls; one more character: "This note is full: 16 KB". A file of 16,398 bytes: "Too big to edit: 16 KB at most" |
+| Rename, delete, sort | `r` renamed `orphan.txt` to `orphan2.txt`; `d` asked, then deleted; `s` switched between newest first and by file name |
+| `e` in the Storage App | A note opened from the text viewer, edited, saved on Back; the listing shows its new size |
+| Memory | IRC connected, the full 16 KB note open: 55 KB free, largest block 31.7 KB (72 KB free before opening) |
+
+**Not checked:** accents through the Compose Key and Ctrl+A / Ctrl+E (the remote `key` command can't send them; the model's tests cover both), the power button's save (it needs a hand on the device), a missing card, and how typing feels on the keyboard itself.
+
+**One slip during the checks:** a key sequence sent right after a restart opened IRC instead of Notes, and the test letters went into IRC's input line. Nothing was sent: the line was cleared and the App left. IRC connected to Libera as it does when opened.
@@ -0,0 +1,125 @@
+# R1 — Releases
+
+**Status:** in progress. CI and signed releases on Gitea (issue #5) are in place since 2026-10-06: every tag from v0.1.0 to v0.10.0 has its release. Updates from Gitea (issue #6) is built and checked on the device, on branch `gitea-updates`, not merged yet. The Issues App (#4) comes after.
+
+**Goal:** a tag is a release, built the same way every time and published where a device can find it.
+
+## CI and releases (issue #5)
+
+Until now the tests, the builds, the signing and the flashing all happened on one machine, through `scripts/ci.sh` and `scripts/flash.sh`. Nothing was published.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q151 | A push to `main`: the host tests (with their coverage). A push to another branch: nothing, its pull request is what runs (a branch with an open pull request ran twice, once for each). A pull request: the same and both builds; changes reach `main` through pull requests. A tag `v*`: all of it, then a release. (First: everything on every push, which rebuilt the firmware far more often than anyone looked at it.) |
+| Q152 | **CI signs.** The signing key is the repository secret `OTA_SIGNING_KEY`; a tag push makes a complete, signed release with no manual step (ADR 0008). |
+| Q153 | The Debug Build is built in CI with a token of the runner's own, to prove it compiles, and **isn't published**: it would hand everyone its Debug Console token. |
+| Q154 | Pull requests from forks don't start a run. |
+| Q155 | A release carries `roro9stack-<version>.ota` (signed), `-factory.bin` for USB, `.elf.gz` to decode crashes, and `SHA256SUMS`. |
+| Q156 | Its text is the tag's message, what the files are, and the commits since the tag before. |
+| Q157 | No cache service to begin with: measure first. |
+| Q158 | Reproducible builds aren't needed for signing any more (Q152); not pursued here. |
+| Q159 | **The tags from before CI get their releases too**, v0.1.0 to v0.10.0, built from each tag's own sources by running the workflow by hand. |
+| Q160 | Actions is switched on for the repository. |
+| Q161 | **Changes reach `main` through pull requests, merged as "rebase, then a merge commit"**, the only style the repository allows: the branch's commits keep their messages, the merge commit marks the pull request, and what CI tested is what lands. No squash, no fast-forward. |
+
+### As built
+
+- **One workflow, `.gitea/workflows/ci.yml`, one job**, on the runner `runner0` (label `ubuntu`). The job asks for a `python:3.12-slim` container, installs git, a compiler, openssl and PlatformIO, and runs the same scripts as a developer's machine. No Docker inside the job.
+- **The cache is a Docker volume**, `roro9stack-pio`, mounted at `/pio`; the runner's `config.yaml` allows it under `container.valid_volumes`. A first run downloads about 1 GB and rebuilds the framework (17 minutes); with the volume filled, tests and both builds take about 6.
+- **No JavaScript actions**, so the image needs no Node and nothing is fetched from GitHub: the checkout is four git commands.
+- **`scripts/_docker.sh`** runs the command in place when `RORO_NO_DOCKER` is set (a CI job is already in a build container), and in the project's image otherwise. The Debug Build's token is made on the spot in CI and goes with the container.
+- **`scripts/release_build.sh <checkout> <out>`** builds a tag's own sources with today's tools, signs, verifies against the public key in those sources, and writes the files and the release's text. **`scripts/release_publish.py`** creates the Gitea release or completes it; run twice, it replaces what's there. Both run the same on a developer's machine.
+- **`scripts/ota_verify.py`** checks an Update File as a device does, on a PC.
+- **The job's own token** (`secrets.GITEA_TOKEN`) is enough to create a release and upload its files.
+- **Old tags.** v0.1.0 to v0.3.0 are from before the framework was rebuilt with our settings (ADR 0006) and can't link against a rebuilt one left in the cache: the release build puts the stock framework libraries back for them. v0.1.0 to v0.2.1 have no public key in their sources (Firmware Updates came with v0.3.0); their files are checked against today's.
+
+### How it went
+
+- **The runner's label took three tries.** Registered as `ubuntu://docker:ubuntu:resolute` and then as `ubuntu::docker://...`, Gitea took the whole string for the label's name; with the first, jobs ran on the runner's host itself. The first version of the workflow was written for that (plain shell, `docker run` for the build) and published v0.10.0 that way. `ubuntu:docker://docker.gitea.com/runner-images:ubuntu-latest` is the form that works.
+- **Gitea 1.27's API can't cancel a run that isn't finished**, only delete a finished one; switching Actions off and on for the repository doesn't either. Runs queued for a label that no longer exists stay queued until cancelled in the web UI.
+- **CI's image isn't byte-identical to a local build of the same tag** (same size, different bytes). Not pursued (Q158).
+
+## Updates from Gitea (issue #6)
+
+The device looks at the project's Gitea for a newer release, says so, and installs it on request, with the same signed Update Files, Probation and rollback as a push from the PC or an install from the card.
+
+### What the server gives (checked 2026-10-06)
+
+- **Its certificate** is Let's Encrypt, all ECDSA: leaf `git.twis.la` (renewed every few months, next expiry 2026-12-14) under the intermediate YE2, Root YE and ISRG Root X2, which X1 cross-signs. Pinning the leaf would ask a question at every renewal.
+- **The API** answers over HTTP/1.1, chunked: `releases/latest` is 3.2 KB (about 350 bytes of it matter), a list of ten releases is 33 KB.
+- **A download** is a direct 200 with `Content-Length` and no redirect; ranges work.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q162 | **Trust:** the firmware carries ISRG Root X1 and X2 and checks the server's chain and name against them, not the framework's bundle of about 130 CAs (ADR 0009). Shared with #4. If the server moves to another CA, the next firmware comes from the PC. |
+| Q163 | The Update File's own signature stays the real guard. A hijacked connection could hide a release or offer an older signed one, never install firmware that isn't ours. |
+| Q164 | The source, `git.twis.la` and `twisla/roro9stack`, is a constant in the firmware. A fork changes it, and has its own key. |
+| Q165 | **When:** on request in Settings > Firmware, and once a day in the background while Wi-Fi is up and the Clock is set (certificate dates need it). A setting, **Check for updates**, on by default. It installs nothing by itself; it skips quietly below the memory floor and never runs during an install. |
+| Q166 | A Toast, "Update v0.11.0 available: see Settings > Firmware", once per version per boot. |
+| Q167 | **The download goes straight into the inactive slot,** no card needed. A truncated or tampered file is refused after 160 bytes or at its end, and the running firmware is untouched. A failed download starts over. |
+| Q168 | A version that failed (rolled back) isn't announced again by the background check until a newer one exists; it can still be installed by hand. |
+| Q169 | **Older releases:** a list of the last ten, newest first, the running one marked. Installing an older one asks with a stronger warning. |
+| Q170 | Enter on a release shows its version, date, size and the tag message, with Install. |
+| Q171 | **Debug Builds** check and show the latest release, but don't install it: it would replace the Debug Build and its console (Q153: Debug Builds aren't published). Their updates come from the PC. |
+| Q172 | **Memory, as measured:** a TLS connection peaks at about 52 KB of heap, with or without checking the certificate, so it starts with 80 KB free (Q86's 20 KB spare on top), not 55 KB. **A check, list or install someone asked for makes IRC step aside** and come back after; the daily check never does, and with IRC connected it waits. (First: 55 KB and nothing else. With IRC connected a check left 3 KB and a download 836 bytes.) |
+| Q173 | Left out, each with its issue: installing automatically (#52), a release channel (#53), resuming a download (#54). |
+| Q174 | Ships as **v0.11.0**. Tested on the device with the real signed releases; a Debug Build command pretends the device runs an older version, so v0.10.0 counts as an update. |
+
+### Done when
+
+- A check, by hand or daily, tells the right thing: up to date, newer available, no network, bad certificate, no clock, too little memory.
+- A newer release installs from the Firmware page with no card and no PC, and the device restarts into it and confirms it.
+- A tampered or truncated download is refused and the running firmware keeps running.
+- The Older releases list shows ten, and installing one asks first.
+- A release that rolled back isn't announced again.
+- A Debug Build shows the latest release and doesn't install it.
+- The daily check never runs below the memory floor, during an install, or without a clock.
+
+### Work breakdown
+
+1. **Model** (host-tested): a streaming JSON scanner, the release list read from it, HTTP response heads and chunked bodies, URLs, which release counts as an update.
+2. **The connection:** the root certificates, an HTTPS client, a check and a list from the Update Service's task; console commands to try them.
+3. **The download:** an HTTPS source for the existing install path.
+4. **The screens:** the Firmware page's release rows, the release page, Older releases, the setting, the daily check and its Toast.
+5. **Checks on the device**, recorded here.
+
+### As built
+
+- **`lib/release`** (host-tested): a streaming JSON scanner, the release reader built on it, HTTP heads and chunked bodies, URLs, and the decisions (which release is an update, whether to announce it, which download URLs are taken). A list of ten releases is 33 KB of JSON and costs a few hundred bytes of memory, because nothing is kept but the path.
+- **`HttpsGet`** (`src/platform`): one GET, the answer read as a stream, redirects not followed. **`GiteaReleases`** keeps the latest and the list. **The Update Service** serves the requests on its own task (about 5.4 KB of its 7 KB stack at the peak) and installs through the install path that already existed, with an HTTPS source in place of the card or the TCP port.
+- **The daily check** is scheduled from the Update Service's tick: Wi-Fi up, the Clock set, no Probation, nothing else going on, memory for a connection. The day it last succeeded is kept in flash.
+- **A version that failed** (rolled back) is remembered as `ota_failed`, and isn't announced again by the daily check.
+- **The screens:** the Firmware page's Latest release and Older releases rows, a release page with the tag's message, and the install dialog.
+- **Debug Builds** get knobs to try what can't be tried otherwise: `update pretend`, `probe`, `damage` and `daily`.
+- **The first message,** `... available: see Settings > Firmware`, was cut at 48 bytes by the notification's own limit; it now reads `v0.11.0 is out: see Settings > Firmware`.
+
+### Checks on the device (2026-10-06, Debug Builds of branch `gitea-updates`)
+
+| Check | Result |
+|---|---|
+| Host tests | 456 pass |
+| Check and list against the live server | The certificate is accepted against the two embedded roots; `releases/latest` read; a list of ten (33 KB) streamed |
+| Servers that must be refused | github.com, example.com, expired.badssl.com, self-signed.badssl.com, wrong.host.badssl.com, untrusted-root.badssl.com and the router: each "isn't accepted" or a TLS error |
+| A download cut short at 800,000 bytes | Refused, "update file too short"; the running firmware untouched |
+| One byte flipped in the signature | Refused after 160 bytes, "bad signature"; the image isn't read further |
+| One byte flipped in the image | Downloaded in full, refused at its end, "image corrupted (hash mismatch)" |
+| The real v0.10.0, from the console and then from the screen | Downloaded, restarted, confirmed on Probation: the slot table read `v0.10.0, valid` both times. The Debug Build was pushed back from the PC after each |
+| The screens | Latest release (checking, then `(current)` or `(new)`), the release page with the tag's message, Older releases with ten rows, the install dialog (Cancel by default, Back cancels), the progress screen at 28% |
+| IRC connected, before the hold | A check left 3 KB of heap; a full download, 836 bytes |
+| IRC connected, with the hold | The lowest free heap during a full download: 38 KB. IRC reconnected afterwards (its counters kept growing) |
+| The daily check | It ran by itself, announced `v0.10.0 is out: see Settings > Firmware` once; with IRC connected (68 KB free) it didn't run |
+| Speed | 1.9 MB in about 46 s, 40 KB/s, over the guest Wi-Fi at -65 dBm; not investigated further |
+
+**Not checked:** the certificate's **name** on its own. Connecting by IP makes the server end the handshake before it shows its certificate, so that test proved nothing; the library sets the name it verifies, and OpenSSL on the PC refused the wrong name against the same chain. A failed daily check retrying, the clock not being set, the release that failed before not being announced (host-tested, not on the device), and the hold when IRC isn't connected but Gemini holds memory.
+
+**Limits worth knowing:**
+- **With IRC connected for days, the daily check doesn't run.** It would have to take IRC down to make room. Opening Latest release does.
+- **A server that changes CA can't be reached** until a firmware carrying the new root comes from the PC (ADR 0009).
+- **No resuming:** a broken download starts over (#54).
+- **A key press during the hold:** Back on the Firmware page while a check is going doesn't cancel it.
+
+**Two slips during the checks:** a blind sequence of keys on the Firmware page opened the SD card's install dialog (the page keeps its selection between visits); it was cancelled with Back, nothing installed. And my port-polling while waiting for a restart took the Debug Console's only client slot, which made the first install attempt look like a failure.
@@ -1,6 +1,6 @@
 # S1 — System basics

-**Status:** in progress (branch `s1`). The SD driver fix shipped in v0.6.1 (issue #21, ADR 0007). Fixed IPv4 settings (issue #7) are done and checked on the device. The System Monitor (#11) hasn't started.
+**Status:** the three planned items are done: the SD driver fix in v0.6.1 (issue #21, ADR 0007), fixed IPv4 settings in v0.7.0 (issue #7), the System App in v0.8.0 (issue #11). v0.8.1 adds the resting main loop (issue #40) and the GNSS pause for the radio's noise (issue #20, still open for the 11 dB that remain). Still open in the milestone: #39, following the SD driver upstream.

 **Goal:** the device works on any network, the card can be trusted, and you can see what the system is doing. A side milestone, like G1.

@@ -59,3 +59,80 @@ The network is 10.39.39.0/24, gateway 10.39.39.1; DHCP gives 10.39.39.1 as DNS a
 3. **Wi-Fi Service:** apply it when joining; DNS and NTP; `wifi status` and the console commands.
 4. **Settings:** the network page, the DNS and NTP rows, connection details.
 5. **Tests on the device**, recorded here.
+
+## System Monitor (issue #11)
+
+Every milestone so far was driven by measurements, heap floors, stack sizes, TLS dips, that needed a Debug Build and a computer. The System App shows them on the device, in any build.
+
+### Decisions (design round 2026-10-06)
+
+| # | Decision |
+|---|---|
+| Q117 | An App of its own, **System**, in release builds too. Read-only. |
+| Q118 | Four views, switched with Tab: **Overview** (CPU per core, memory, network, battery), **Tasks**, **Memory**, **System**. |
+| Q119 | Sampled once a second. A task's share is its run time over the last second; a core's load is 100 % minus its idle task's share. |
+| Q120 | **History only while the App is open:** two minutes at one sample a second, about 1 KB. The system already keeps what matters afterwards: the lowest free heap since boot and each task's lowest free stack. |
+| Q121 | **Bytes are counted per service:** IRC, Gemini, the Debug Console and Firmware Updates add what they read and write to a shared counter. The network view shows the connection details, each service's bytes in and out, and the signal strength. |
+| Q122 | Tasks: name, core, share, state and lowest free stack, sorted by share; `s` cycles the sort (share, stack, name). **Under 512 bytes of stack left shows in the warning colour.** |
+| Q123 | Memory: free heap, lowest since boot, largest free block, and a two-minute graph of free heap **with the floors of Q86 drawn as lines** (55, 40 and 20 KB). |
+| Q124 | System: uptime and why it last started, firmware and both app slots, chip temperature and CPU frequency, battery voltage and percentage, SD usage and write faults, the radio's and the GNSS receiver's state. |
+| Q125 | `info` and `tasks` are split into a **snapshot** that the console and the App share; the arithmetic (shares from two samples, sorting, the stack warning) is host-tested. |
+| Q126 | Left out: acting on tasks, an event log, exporting snapshots to the card. |
+| Q127 | The main loop uses about 81 % of a core. The App shows it; fixing it is issue #40, not part of #11. |
+
+The App has five views, not four: Q121's network view is one of its own (Overview, Tasks, Memory, Network, System).
+
+### Measured (2026-10-06)
+
+- **Traffic counters are exact.** A Gemini fetch of a 164,970-byte page counts 164,986 bytes in (the page and its 16-byte header line) and 42 out (the 40-character URL and CRLF). A 1,797,760-byte upload counts 1,798,123 in for the Debug Console, commands included.
+- **The Memory view shows a TLS dip as it happens.** Starting IRC and a 165 KB Gemini fetch together: free heap falls from about 100 KB through the three floors to a low of 12.1 KB, then settles near 50 KB. That's the dip accepted in G1 (Q86).
+- **A run-time counter only moves when its task is switched out.** FreeRTOS adds to a task's run time at the context switch. The main loop takes the samples, and with core 1 to itself it's never switched out: its counter said 2 % while the core's idle task had 0 %. So the task that samples gets what's left of its core. With that: **the main loop uses 100 % of core 1 at rest** (issue #40 said 81 %, an average since boot).
+- **`tasks` on the console** sampled twice inside one command at first, a quarter second apart, and showed the loop at 1 %: it was asleep in the command's own wait. It now samples, lets the loop run for a second, and prints.
+- **Low stack, flagged:** `IDLE0` (232 bytes left), `IDLE1` (328 to 352) and `spk_task` (256 to 264), all the framework's own tasks.
+- **Cost:** 15.6 KB of flash for the App and the counters (1,742,723 bytes, release). Nothing while it's closed; about 2 KB of history and samples while it's open.
+
+## The main loop rests (issue #40)
+
+The loop polled the keyboard, ticked the Services, ran the consoles and redrew when needed, then came straight back: 50,000 passes a second, and core 1 100 % busy with the device idle and the screen off.
+
+Nothing needs that. The keyboard controller buffers key events; the consoles and the radio have their own tasks or interrupts; no Service asks for a tick more often than every 50 ms. So after each pass the loop now rests: **5 ms with the screen on, 20 ms with it off**, and not at all during a serial file transfer (`sd put`), which reads its bytes from the loop. Safe Mode's loop rests 5 ms too. Debug Builds have `loop spin on|off` to bring the old behaviour back for comparison.
+
+### Measured (2026-10-06, Debug Build, Wi-Fi connected, GNSS on, on USB power)
+
+| | Spinning | Resting |
+|---|---|---|
+| Passes a second, screen off | 50,160 | 50 |
+| Core 1 load, screen off | 100 % | 1 % |
+| Passes a second, screen on (Launcher) | 1,203 | 167 |
+| Core 1 load, screen on | 62 % | 10 % |
+| Chip temperature at rest, settled | 38.3 C | 34.3 C |
+| A 1.8 MB upload over the Debug Console | about 230 KB/s | 288 KB/s |
+
+- Still working at this pace: GNSS (a 3D Fix, 22 satellites), a Gemini fetch (52 KB), the upload read back by SHA-256, the Sweep (still 606 to 610 ms a pass), the radio's DIO1 interrupt.
+- **Not measured:** the current drawn (no meter on the battery line), and how typing feels on the real keyboard: a key now waits up to 5 ms for the loop, 20 ms if it's the one that wakes the screen.
+- **The radio's noise floor didn't move** (-97 to -99 dBm at 125 kHz either way): the spinning loop wasn't the source (issue #20).
+- **Not done:** real sleep. The framework is built without power management (`CONFIG_PM_ENABLE` is off), so an idle core only halts until the next interrupt. Automatic light sleep would need the framework rebuilt with it, Wi-Fi in modem sleep, and the USB serial port's behaviour checked. A next step if battery life calls for it.
+
+## The radio's noise: the GNSS receiver (issue #20)
+
+M3 found the LoRa radio's noise floor about 15 dB above what the chip hears alone, and that the source travels with the device. Which part? Debug Builds got a self-test, `lora noise test`: it changes one thing at a time, Sweeps the band eight passes (568 readings), records the median as the floor, and puts the thing back. It runs on the device by itself, because one condition switches Wi-Fi off, and `lora noise report` prints the result afterwards.
+
+### Measured (2026-10-06, indoors, on USB power, dBm at 125 kHz)
+
+| Condition | Floor |
+|---|---|
+| Antenna switched off (the chip alone) | -117 |
+| Antenna on, GNSS in standby | -106 |
+| Antenna on, GNSS running (as shipped) | -98 |
+
+- **The GNSS receiver, while it runs, raises the floor by 8 dB.** Three runs: -98 or -99 with it running, -106 in standby, every time. On LongFast (250 kHz) the Sniffer's own reading goes from about -93.5 to -101.5 dBm.
+- **It's the receiver working, not its serial line:** with one NMEA sentence a second instead of twenty (`PCAS03`), the receiver still tracking, the floor stays at -98.
+- **Nothing else moves it by more than 1 dB**, with GNSS running or in standby: the main loop spinning or resting, the CPU at 240, 160 or 80 MHz, Wi-Fi on or off, the screen on or off, the radio chip's regulator as DC-DC or LDO, its receive gain boosted or not.
+- **11 dB remain** between the antenna connected with GNSS quiet (-106) and the chip alone (-117). It comes in through the antenna and none of those switches changes it: the surroundings, or parts of the Cardputer that can't be switched off. Not separated: that needs another place, or the antenna on a cable away from the case.
+- M3's quick check had GNSS at "1 or 2 dB": it read one frequency for a few seconds, in a noisier spot. The median over the band is the better measure.
+
+### What the firmware does about it
+
+**Settings > Pause GNSS for LoRa**, off by default: while the LoRa radio listens or sweeps, the GNSS receiver waits in standby, and wakes when the radio goes back to sleep (a Fix again after about 7 s here). Never during a Track. The GNSS App says "GNSS is paused" meanwhile. `gnss quiet on|off` on the console.
+
+It's off by default because GNSS on by default was decided in M2 (Q58), and from M4 the radio listens all the time: then "pause while listening" means GNSS mostly off, which is a decision about position, the clock and Tracks, for M4's design round (issue #23).
@@ -20,10 +20,10 @@ const RowDef kRows[] = {
    {Row::Region, Kind::Choice, "Region"},      {Row::Timezone, Kind::Choice, "Timezone"},
    {Row::Brightness, Kind::Slider, "Brightness"}, {Row::DimTimeout, Kind::Choice, "Dim after"},
    {Row::OffTimeout, Kind::Choice, "Screen off after"}, {Row::Sound, Kind::Toggle, "Sound & LED"},
-    {Row::Gnss, Kind::Toggle, "GNSS"}, {Row::Coordinates, Kind::Toggle, "Coordinates"},
+    {Row::Gnss, Kind::Toggle, "GNSS"}, {Row::GnssQuiet, Kind::Toggle, "Pause GNSS for LoRa"},
+    {Row::Coordinates, Kind::Toggle, "Coordinates"},
    {Row::ProbeMacs, Kind::Toggle, "Probe MACs"}, {Row::Wifi, Kind::Page, "Wi-Fi"},
-    {Row::Storage, Kind::Page, "Storage"},
-    {Row::Firmware, Kind::Page, "Firmware"},
+    {Row::CheckUpdates, Kind::Toggle, "Check for updates"}, {Row::Firmware, Kind::Page, "Firmware"},
    {Row::About, Kind::Page, "About"},
 };

@@ -81,6 +81,8 @@ std::string SettingsMenu::value(int i) const {
        case Row::OffTimeout: return formatSeconds(settings_.getInt(Setting::OffTimeoutS));
        case Row::Sound: return settings_.getBool(Setting::Sound) ? "On" : "Off";
        case Row::Gnss: return settings_.getBool(Setting::GnssEnabled) ? "On" : "Off";
+        case Row::GnssQuiet: return settings_.getBool(Setting::GnssQuietForLora) ? "On" : "Off";
+        case Row::CheckUpdates: return settings_.getBool(Setting::CheckUpdates) ? "Daily" : "Off";
        case Row::Coordinates: return settings_.getBool(Setting::CoordinatesDms) ? "Deg min sec" : "Decimal";
        case Row::ProbeMacs: return settings_.getBool(Setting::ProbeMacRaw) ? "Raw" : "Pseudonymised";
        case Row::Wifi: return settings_.getBool(Setting::WifiEnabled) ? "On" : "Off";
@@ -126,6 +128,8 @@ std::string SettingsMenu::choose(int i, int c) {
 void SettingsMenu::toggle(int i) {
    if (row(i) == Row::Sound) settings_.setBool(Setting::Sound, !settings_.getBool(Setting::Sound));
    if (row(i) == Row::Gnss) settings_.setBool(Setting::GnssEnabled, !settings_.getBool(Setting::GnssEnabled));
+    if (row(i) == Row::GnssQuiet) settings_.setBool(Setting::GnssQuietForLora, !settings_.getBool(Setting::GnssQuietForLora));
+    if (row(i) == Row::CheckUpdates) settings_.setBool(Setting::CheckUpdates, !settings_.getBool(Setting::CheckUpdates));
    if (row(i) == Row::Coordinates) settings_.setBool(Setting::CoordinatesDms, !settings_.getBool(Setting::CoordinatesDms));
    if (row(i) == Row::ProbeMacs) settings_.setBool(Setting::ProbeMacRaw, !settings_.getBool(Setting::ProbeMacRaw));
 }
@@ -11,7 +11,7 @@ namespace roro {
 // values, choice lists and validation messages. Rendering and navigation live in the App.
 class SettingsMenu {
   public:
-    enum class Row { LongName, ShortName, Region, Timezone, Brightness, DimTimeout, OffTimeout, Sound, Gnss, Coordinates, ProbeMacs, Wifi, Storage, Firmware, About };
+    enum class Row { LongName, ShortName, Region, Timezone, Brightness, DimTimeout, OffTimeout, Sound, Gnss, GnssQuiet, Coordinates, ProbeMacs, Wifi, CheckUpdates, Firmware, About };
    enum class Kind { Text, Choice, Toggle, Slider, Page };

    explicit SettingsMenu(Settings& settings) : settings_(settings) {}
@@ -0,0 +1,137 @@
+#include "file_list.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+#include <ctime>
+
+namespace roro::files {
+
+namespace {
+
+// Names compare letters only, whatever the case; ties by the bytes, so the order is total.
+int compareNames(const char* a, const char* b) {
+    for (const char *x = a, *y = b;; ++x, ++y) {
+        int cx = std::tolower(static_cast<unsigned char>(*x)), cy = std::tolower(static_cast<unsigned char>(*y));
+        if (cx != cy) return cx < cy ? -1 : 1;
+        if (!cx) break;
+    }
+    return std::strcmp(a, b);
+}
+
+constexpr uint32_t kYear2020 = 1577836800;
+
+std::string sizeText(uint32_t bytes) {
+    char s[16];
+    if (bytes < 1024) std::snprintf(s, sizeof s, "%u B", static_cast<unsigned>(bytes));
+    else if (bytes < 10 * 1024) std::snprintf(s, sizeof s, "%.1f KB", bytes / 1024.0);
+    else if (bytes < 1024 * 1024) std::snprintf(s, sizeof s, "%u KB", static_cast<unsigned>(bytes / 1024));
+    else if (bytes < 10u * 1024 * 1024) std::snprintf(s, sizeof s, "%.1f MB", bytes / 1048576.0);
+    else if (bytes < 1024u * 1024 * 1024) std::snprintf(s, sizeof s, "%u MB", static_cast<unsigned>(bytes / 1048576));
+    else std::snprintf(s, sizeof s, "%.1f GB", bytes / 1073741824.0);
+    return s;
+}
+
+}  // namespace
+
+void FileList::clear() {
+    std::vector<Entry>().swap(entries_);
+    std::vector<uint16_t>().swap(order_);
+    std::vector<char>().swap(names_);
+    more_ = wasted_ = 0;
+}
+
+bool FileList::before(const Entry& a, const Entry& b, FileSort by) const {
+    if (a.folder != b.folder) return a.folder;
+    if (!a.folder) {
+        if (by == FileSort::Date && a.modified != b.modified) return a.modified > b.modified;
+        if (by == FileSort::Size && a.size != b.size) return a.size > b.size;
+    }
+    return compareNames(names_.data() + a.name, names_.data() + b.name) < 0;
+}
+
+void FileList::add(const char* name, uint32_t size, uint32_t modified, bool folder) {
+    size_t len = std::strlen(name) + 1;
+    if (entries_.size() >= kMax) {
+        // Full: the new entry takes the place of the one that sorts last by name, if it sorts
+        // before it. The old name's bytes stay in the buffer until there's enough waste to pack.
+        more_++;
+        size_t last = 0;
+        for (size_t i = 1; i < entries_.size(); i++)
+            if (before(entries_[last], entries_[i], FileSort::Name)) last = i;
+        Entry candidate{static_cast<uint32_t>(names_.size()), size, modified, folder};
+        names_.insert(names_.end(), name, name + len);
+        if (!before(candidate, entries_[last], FileSort::Name)) {
+            names_.resize(names_.size() - len);
+            return;
+        }
+        wasted_ += std::strlen(names_.data() + entries_[last].name) + 1;
+        entries_[last] = candidate;
+        if (wasted_ > 2048) compact();
+        return;
+    }
+    if (entries_.empty()) {
+        entries_.reserve(32);
+        names_.reserve(512);
+    }
+    entries_.push_back({static_cast<uint32_t>(names_.size()), size, modified, folder});
+    names_.insert(names_.end(), name, name + len);
+    order_.push_back(static_cast<uint16_t>(order_.size()));
+}
+
+void FileList::compact() {
+    std::vector<char> packed;
+    packed.reserve(names_.size() - wasted_);
+    for (Entry& e : entries_) {
+        const char* n = names_.data() + e.name;
+        e.name = static_cast<uint32_t>(packed.size());
+        packed.insert(packed.end(), n, n + std::strlen(n) + 1);
+    }
+    names_.swap(packed);
+    wasted_ = 0;
+}
+
+void FileList::sort(FileSort by) {
+    if (wasted_) compact();
+    names_.shrink_to_fit();
+    entries_.shrink_to_fit();
+    order_.resize(entries_.size());
+    for (size_t i = 0; i < order_.size(); i++) order_[i] = static_cast<uint16_t>(i);
+    std::sort(order_.begin(), order_.end(), [&](uint16_t a, uint16_t b) { return before(entries_[a], entries_[b], by); });
+}
+
+int FileList::find(const std::string& name) const {
+    for (size_t i = 0; i < order_.size(); i++)
+        if (name == this->name(i)) return static_cast<int>(i);
+    return -1;
+}
+
+size_t FileList::bytes() const {
+    return entries_.capacity() * sizeof(Entry) + order_.capacity() * sizeof(uint16_t) + names_.capacity();
+}
+
+std::string formatStamp(uint32_t modified) {
+    if (modified < kYear2020) return "-";
+    time_t t = static_cast<time_t>(modified);
+    struct tm local;
+    localtime_r(&t, &local);
+    char s[20];
+    std::snprintf(s, sizeof s, "%04d-%02d-%02d %02d:%02d", local.tm_year + 1900, local.tm_mon + 1, local.tm_mday, local.tm_hour,
+                  local.tm_min);
+    return s;
+}
+
+std::string rowDetail(bool folder, uint32_t size, uint32_t modified) {
+    if (folder) return "folder";
+    std::string stamp = formatStamp(modified);
+    return sizeText(size) + "  " + (stamp == "-" ? stamp : stamp.substr(0, 10));
+}
+
+std::string fitName(const std::string& name, size_t maxChars) {
+    if (name.size() <= maxChars || maxChars < 8) return name.substr(0, maxChars);
+    size_t tail = std::min<size_t>(6, maxChars / 3), head = maxChars - tail - 2;
+    return name.substr(0, head) + ".." + name.substr(name.size() - tail);
+}
+
+}  // namespace roro::files
@@ -0,0 +1,55 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace roro::files {
+
+enum class FileSort : uint8_t { Name, Date, Size };
+
+// A folder's entries for the Storage App (F1, Q129, Q136): 256 at most, the names packed into
+// one buffer, about 10 KB when full. A bigger folder keeps the first 256 by name, whatever order
+// the card lists them in, and counts the rest.
+class FileList {
+   public:
+    static constexpr size_t kMax = 256;
+
+    void clear();
+    void add(const char* name, uint32_t size, uint32_t modified, bool folder);
+    void sort(FileSort by);  // folders first, by name; then files by name, newest or biggest first
+
+    size_t count() const { return entries_.size(); }
+    size_t more() const { return more_; }  // entries that didn't fit
+    // By position after sort().
+    const char* name(size_t i) const { return names_.data() + entries_[order_[i]].name; }
+    uint32_t size(size_t i) const { return entries_[order_[i]].size; }
+    uint32_t modified(size_t i) const { return entries_[order_[i]].modified; }  // Unix time, 0 if unknown
+    bool folder(size_t i) const { return entries_[order_[i]].folder; }
+    int find(const std::string& name) const;  // position, or -1
+    size_t bytes() const;                     // memory held
+
+   private:
+    struct Entry {
+        uint32_t name;  // offset into names_
+        uint32_t size, modified;
+        bool folder;
+    };
+    bool before(const Entry& a, const Entry& b, FileSort by) const;
+    void compact();
+
+    std::vector<Entry> entries_;
+    std::vector<uint16_t> order_;
+    std::vector<char> names_;
+    size_t more_ = 0, wasted_ = 0;
+};
+
+// What a row shows on the right (Q129): "folder", or "1.2 KB  2026-10-05". A file dated before
+// 2020 was written before the clock was set: "-" (Q137). Local time.
+std::string rowDetail(bool folder, uint32_t size, uint32_t modified);
+std::string formatStamp(uint32_t modified);
+// A name cut to `maxChars` for a row, from the middle: the start and the extension stay readable.
+std::string fitName(const std::string& name, size_t maxChars);  // "2026-10-05 20:00", or "-"
+
+}  // namespace roro::files
@@ -0,0 +1,99 @@
+#include "file_names.h"
+
+#include <cctype>
+
+namespace roro::files {
+
+const char* const kFirmwareFolders[] = {"/irc", "/wifi", "/updates", "/gnss", "/gemini", "/captures", "/notes"};
+const size_t kFirmwareFolderCount = sizeof kFirmwareFolders / sizeof kFirmwareFolders[0];
+
+std::string parentOf(const std::string& path) {
+    size_t slash = path.rfind('/');
+    return slash == std::string::npos || slash == 0 ? "/" : path.substr(0, slash);
+}
+
+std::string baseName(const std::string& path) {
+    size_t slash = path.rfind('/');
+    return slash == std::string::npos ? path : path.substr(slash + 1);
+}
+
+std::string joinPath(const std::string& folder, const std::string& name) {
+    return folder == "/" ? "/" + name : folder + "/" + name;
+}
+
+std::string extensionOf(const std::string& name) {
+    size_t dot = name.rfind('.');
+    if (dot == std::string::npos || dot == 0) return "";
+    std::string ext = name.substr(dot + 1);
+    for (char& c : ext) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+    return ext;
+}
+
+bool isInside(const std::string& path, const std::string& folder) {
+    if (folder == "/") return true;
+    if (path.compare(0, folder.size(), folder) != 0) return false;
+    return path.size() == folder.size() || path[folder.size()] == '/';
+}
+
+std::string checkName(const std::string& name) {
+    if (name.empty()) return "A name can't be empty";
+    if (name == "." || name == "..") return "\".\" and \"..\" aren't names";
+    if (name.size() > 64) return "A name can be 64 characters at most";
+    for (char c : name) {
+        if (static_cast<unsigned char>(c) < 0x20) return "A name can't contain control characters";
+        for (char bad : std::string("/\\:*?\"<>|"))
+            if (c == bad) return std::string("A name can't contain ") + c;
+    }
+    if (name.back() == '.' || name.back() == ' ') return "A name can't end with a dot or a space";
+    return "";
+}
+
+std::string whyReadOnly(const std::string& path, const std::vector<std::string>& inUse) {
+    if (path == "/" || path.empty()) return "That's the card itself";
+    if (isInside(path, kGeminiCache)) return std::string(kGeminiCache) + " is the Gemini App's working space";
+    for (const std::string& open : inUse) {
+        if (open == path) return "It's being written right now";
+        if (isInside(open, path)) return "It holds a file that's being written right now";
+    }
+    for (size_t i = 0; i < kFirmwareFolderCount; i++)
+        if (path == kFirmwareFolders[i]) return std::string("The firmware keeps its files in ") + path;
+    return "";
+}
+
+std::string whyNotInto(const std::string& source, const std::string& into) {
+    if (isInside(into, kGeminiCache)) return std::string(kGeminiCache) + " is the Gemini App's working space";
+    if (isInside(into, source)) return "A folder can't go inside itself";
+    if (parentOf(source) == into) return "It's already there";
+    return "";
+}
+
+std::string copyName(const std::string& name, int n) {
+    size_t dot = name.rfind('.');
+    std::string suffix = " (" + std::to_string(n) + ")";
+    if (dot == std::string::npos || dot == 0) return name + suffix;
+    return name.substr(0, dot) + suffix + name.substr(dot);
+}
+
+FileKind kindOf(const std::string& name) {
+    std::string ext = extensionOf(name);
+    if (ext == "gpx") return FileKind::Gpx;
+    if (ext == "pcap") return FileKind::Pcap;
+    if (ext == "ota") return FileKind::Ota;
+    for (const char* text : {"txt", "log", "gmi", "csv", "md", "json", "ini", "conf", "ir"})
+        if (ext == text) return FileKind::Text;
+    return FileKind::Unknown;
+}
+
+bool opensAtEnd(const std::string& name) { return extensionOf(name) == "log"; }
+
+bool looksLikeText(const uint8_t* data, size_t len) {
+    size_t odd = 0;
+    for (size_t i = 0; i < len; i++) {
+        uint8_t b = data[i];
+        if (b == 0) return false;
+        if (b < 0x20 && b != '\n' && b != '\r' && b != '\t') odd++;
+    }
+    return odd * 20 <= len;  // a stray control character or two is still text
+}
+
+}  // namespace roro::files
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace roro::files {
+
+// Paths on the SD card are absolute and use '/': "/gemini/saved/index.gmi".
+std::string parentOf(const std::string& path);    // "/" for a top-level entry and for "/"
+std::string baseName(const std::string& path);    // "" for "/"
+std::string joinPath(const std::string& folder, const std::string& name);
+std::string extensionOf(const std::string& name);  // lower case, without the dot; "" if none
+bool isInside(const std::string& path, const std::string& folder);  // a folder is inside itself
+
+// A name typed for rename or a new folder (F1, Q131): "" if FAT and this App can take it, or why not.
+std::string checkName(const std::string& name);
+
+// The top-level folders the firmware keeps its files in. They can't be renamed or deleted;
+// what's in them can (Q130).
+extern const char* const kFirmwareFolders[];
+extern const size_t kFirmwareFolderCount;
+constexpr const char* kGeminiCache = "/gemini/cache";
+
+// Why `path` can't be renamed, moved or deleted, or "" if it can (Q130). `inUse`: the files the
+// firmware has open right now.
+std::string whyReadOnly(const std::string& path, const std::vector<std::string>& inUse);
+
+// Why `source` can't be copied or moved into the folder `into`, or "" if it can.
+std::string whyNotInto(const std::string& source, const std::string& into);
+
+// "a (2).gmi": the name of a copy made next to its original.
+std::string copyName(const std::string& name, int n);
+
+// Which viewer opens a file (Q134), from its name. Unknown: look at the first bytes.
+enum class FileKind : uint8_t { Text, Gpx, Pcap, Ota, Unknown };
+FileKind kindOf(const std::string& name);
+bool opensAtEnd(const std::string& name);  // logs
+bool looksLikeText(const uint8_t* data, size_t len);
+
+}  // namespace roro::files
@@ -0,0 +1,143 @@
+#include "file_views.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+#include "file_list.h"
+#include "track.h"
+
+namespace roro::files {
+
+std::string hexRow(uint32_t offset, const uint8_t* data, size_t len) {
+    char head[8];
+    std::snprintf(head, sizeof head, "%05X", static_cast<unsigned>(offset));
+    std::string row = head, text;
+    for (size_t i = 0; i < 8; i++) {
+        if (i % 2 == 0) row += ' ';
+        char hex[3] = "  ";
+        if (i < len) {
+            std::snprintf(hex, sizeof hex, "%02x", data[i]);
+            text += data[i] >= 0x20 && data[i] < 0x7F ? static_cast<char>(data[i]) : '.';
+        }
+        row += hex;
+    }
+    return row + "  " + text;
+}
+
+namespace {
+// Days since 1970-01-01 (Howard Hinnant's days_from_civil): no timegm() everywhere.
+int64_t daysFromCivil(int y, int m, int d) {
+    y -= m <= 2;
+    int64_t era = (y >= 0 ? y : y - 399) / 400;
+    int yoe = static_cast<int>(y - era * 400);
+    int doy = (153 * (m + (m > 2 ? -3 : 9)) + 2) / 5 + d - 1;
+    int doe = yoe * 365 + yoe / 4 - yoe / 100 + doy;
+    return era * 146097 + doe - 719468;
+}
+
+bool attribute(const std::string& element, const char* name, double& out) {
+    size_t at = element.find(name);
+    if (at == std::string::npos) return false;
+    const char* from = element.c_str() + at + std::strlen(name);
+    char* end = nullptr;
+    out = std::strtod(from, &end);
+    return end != from;
+}
+}  // namespace
+
+void GpxSummary::point(const std::string& element) {
+    double lat, lon;
+    if (!attribute(element, "lat=\"", lat) || !attribute(element, "lon=\"", lon)) return;
+    if (points_ > 0) meters_ += gnss::distanceMeters(lat_, lon_, lat, lon);
+    lat_ = lat;
+    lon_ = lon;
+    points_++;
+    size_t at = element.find("<time>");
+    int y, mo, d, h, mi, s;
+    if (at != std::string::npos && std::sscanf(element.c_str() + at + 6, "%d-%d-%dT%d:%d:%d", &y, &mo, &d, &h, &mi, &s) == 6) {
+        int64_t t = daysFromCivil(y, mo, d) * 86400 + h * 3600 + mi * 60 + s;
+        if (first_ == 0) first_ = t;
+        last_ = t;
+    }
+}
+
+void GpxSummary::feed(const char* data, size_t len) {
+    carry_.append(data, len);
+    size_t done = 0;
+    for (;;) {
+        size_t open = carry_.find("<trkpt", done);
+        if (open == std::string::npos) {
+            // Nothing begun, except perhaps the first letters of a tag at the very end.
+            done = carry_.size() > 6 ? carry_.size() - 6 : done;
+            break;
+        }
+        size_t close = carry_.find("</trkpt>", open);
+        size_t next = carry_.find("<trkpt", open + 6);  // a point with nothing inside: <trkpt .../>
+        if (close == std::string::npos && next == std::string::npos) {
+            done = open;
+            break;
+        }
+        size_t end = close != std::string::npos && (next == std::string::npos || close < next) ? close + 8 : next;
+        point(carry_.substr(open, end - open));
+        done = end;
+    }
+    carry_.erase(0, done);
+    if (carry_.size() > 2048) carry_.erase(0, carry_.size() - 6);  // not a GPX point: don't keep it
+}
+
+std::string formatDuration(int64_t seconds) {
+    char s[24];
+    if (seconds < 60) std::snprintf(s, sizeof s, "%d s", static_cast<int>(seconds));
+    else if (seconds < 3600) std::snprintf(s, sizeof s, "%d min %02d s", static_cast<int>(seconds / 60), static_cast<int>(seconds % 60));
+    else std::snprintf(s, sizeof s, "%d h %02d min", static_cast<int>(seconds / 3600), static_cast<int>(seconds % 3600 / 60));
+    return s;
+}
+
+std::vector<std::string> GpxSummary::lines() const {
+    std::vector<std::string> out;
+    out.push_back(std::to_string(points_) + (points_ == 1 ? " point" : " points"));
+    if (first_ > 0) {
+        out.push_back("Started " + formatStamp(static_cast<uint32_t>(first_)));
+        out.push_back("Lasted " + formatDuration(last_ - first_));
+    }
+    char s[32];
+    if (meters_ < 1000) std::snprintf(s, sizeof s, "Distance %.0f m", meters_);
+    else std::snprintf(s, sizeof s, "Distance %.2f km", meters_ / 1000);
+    out.push_back(s);
+    return out;
+}
+
+namespace {
+uint32_t le32(const uint8_t* p) { return p[0] | p[1] << 8 | p[2] << 16 | static_cast<uint32_t>(p[3]) << 24; }
+}  // namespace
+
+PcapHeader parsePcapHeader(const uint8_t* data, size_t len) {
+    PcapHeader h;
+    if (len < kPcapHeaderSize || le32(data) != 0xA1B2C3D4) return h;  // little-endian, microseconds: what we write
+    h.ok = true;
+    h.linkType = le32(data + 20);
+    return h;
+}
+
+bool parsePcapRecord(const uint8_t* data, size_t len, PcapRecord& out) {
+    if (len < kPcapRecordSize) return false;
+    out.seconds = le32(data);
+    out.micros = le32(data + 4);
+    out.length = le32(data + 8);
+    return out.length <= 65535;
+}
+
+bool parseLoraTap(const uint8_t* d, size_t len, lora::RxInfo& out) {
+    if (len < lora::kLoraTapSize || d[0] != 0) return false;
+    out.frequencyHz = static_cast<uint32_t>(d[4]) << 24 | d[5] << 16 | d[6] << 8 | d[7];
+    out.bandwidthKHz = d[8] * 125.0f;
+    out.spreadingFactor = d[9];
+    out.rssi = d[10] - 139.0f;
+    out.noiseFloor = d[12] - 139.0f;
+    out.snr = static_cast<int8_t>(d[13]) / 4.0f;
+    out.syncWord = d[14];
+    return true;
+}
+
+}  // namespace roro::files
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "loratap.h"
+
+namespace roro::files {
+
+// What the Storage App's viewers show of the files the firmware writes (F1, Q134).
+
+// One row of a hex dump, eight bytes: "00010 4865 6c6c 6f2c 2077  Hello, w".
+std::string hexRow(uint32_t offset, const uint8_t* data, size_t len);
+
+// A Track (.gpx) read a piece at a time: its points, when it started and ended, how far it went.
+class GpxSummary {
+   public:
+    void feed(const char* data, size_t len);
+
+    uint32_t points() const { return points_; }
+    int64_t start() const { return first_; }  // UTC seconds, 0 if no point carried a time
+    int64_t end() const { return last_; }
+    double meters() const { return meters_; }
+    std::vector<std::string> lines() const;  // for the screen
+
+   private:
+    void point(const std::string& element);
+
+    std::string carry_;  // the part of a point cut by the end of a piece
+    uint32_t points_ = 0;
+    int64_t first_ = 0, last_ = 0;
+    double meters_ = 0, lat_ = 0, lon_ = 0;
+};
+
+// "1 h 02 min", "4 min 10 s", "12 s".
+std::string formatDuration(int64_t seconds);
+
+// A Capture (.pcap): the file's header, then one record after another.
+struct PcapHeader {
+    bool ok = false;
+    uint32_t linkType = 0;  // 270: LoRaTap, what the LoRa Scanner writes
+};
+constexpr size_t kPcapHeaderSize = 24, kPcapRecordSize = 16;
+constexpr uint32_t kLinkLoraTap = 270;
+PcapHeader parsePcapHeader(const uint8_t* data, size_t len);
+
+struct PcapRecord {
+    uint32_t seconds = 0, micros = 0, length = 0;  // length: the bytes that follow in the file
+};
+bool parsePcapRecord(const uint8_t* data, size_t len, PcapRecord& out);  // false: not a record, stop there
+
+// The LoRaTap header a packet starts with; false if `len` is too short for one.
+bool parseLoraTap(const uint8_t* data, size_t len, lora::RxInfo& out);
+
+}  // namespace roro::files
@@ -0,0 +1,121 @@
+#include "text_pager.h"
+
+#include <algorithm>
+
+namespace roro::files {
+
+TextPager::TextPager(ReadAt read, uint32_t size, int cols, int rows)
+    : read_(std::move(read)), size_(size), cols_(std::max(1, cols)), rows_(std::max(1, rows)) {}
+
+const uint8_t* TextPager::bytes(uint32_t at, size_t& len) {
+    len = 0;
+    if (at >= size_) return nullptr;
+    bool cached = at >= cacheAt_ && at < cacheAt_ + cache_.size();
+    // Wanted: a line's worth ahead, unless the cache already reaches the end of the file.
+    size_t ahead = cached ? cacheAt_ + cache_.size() - at : 0;
+    if (!cached || (ahead < kBlock / 4 && cacheAt_ + cache_.size() < size_)) {
+        cacheAt_ = at - std::min<uint32_t>(at, kBlock / 2);  // room behind too: scrolling back is common
+        cache_.resize(std::min<uint32_t>(kBlock, size_ - cacheAt_));
+        cache_.resize(read_(cacheAt_, cache_.data(), cache_.size()));
+        if (at >= cacheAt_ + cache_.size()) return nullptr;  // the file got shorter, or the card failed
+    }
+    len = cacheAt_ + cache_.size() - at;
+    return cache_.data() + (at - cacheAt_);
+}
+
+int TextPager::byteAt(uint32_t at) {
+    size_t len;
+    const uint8_t* p = bytes(at, len);
+    return p ? *p : -1;
+}
+
+uint32_t TextPager::nextLine(uint32_t at, std::string* text) {
+    size_t len;
+    const uint8_t* p = bytes(at, len);
+    if (text) text->clear();
+    if (!p) return size_;
+    size_t end = len, next = len;  // the line is [0, end); the one after starts at `next`
+    int count = 0;
+    size_t lastSpace = 0;
+    for (size_t i = 0; i < len; i++) {
+        uint8_t b = p[i];
+        if (b == '\n') {
+            end = i;
+            next = i + 1;
+            break;
+        }
+        if ((b & 0xC0) == 0x80) continue;  // inside a UTF-8 character
+        if (count == cols_) {              // one character too many: wrap
+            if (b == ' ') end = i, next = i + 1;
+            else if (lastSpace > 0) end = lastSpace, next = lastSpace + 1;
+            else end = next = i;
+            break;
+        }
+        count++;
+        if (b == ' ') lastSpace = i;
+    }
+    if (text) {
+        size_t n = end > 0 && p[end - 1] == '\r' ? end - 1 : end;
+        text->reserve(n);
+        for (size_t i = 0; i < n; i++) text->push_back(p[i] == '\t' ? ' ' : (p[i] < 0x20 || p[i] == 0x7F) ? '.' : static_cast<char>(p[i]));
+    }
+    return at + static_cast<uint32_t>(std::max<size_t>(next, 1));
+}
+
+uint32_t TextPager::lineBefore(uint32_t at) {
+    if (at == 0) return 0;
+    at = std::min(at, size_);
+    // The paragraph the line before `at` belongs to starts after the newline before it. The byte
+    // just before `at` may be that line's own newline.
+    uint32_t from = at - 1;
+    if (from > 0 && byteAt(from) == '\n') from--;
+    uint32_t limit = at > kLookBack ? at - kLookBack : 0, start = limit;
+    for (uint32_t i = from + 1; i-- > limit;) {
+        if (byteAt(i) == '\n' && i < at - 1) {
+            start = i + 1;
+            break;
+        }
+    }
+    // No newline that near: any character boundary will do as a place to wrap from.
+    while (start > 0 && start < at && (byteAt(start) & 0xC0) == 0x80) start++;
+    for (uint32_t a = start;;) {
+        uint32_t next = nextLine(a, nullptr);
+        if (next >= at) return a;
+        a = next;
+    }
+}
+
+bool TextPager::atEnd() {
+    uint32_t a = top_;
+    for (int i = 0; i < rows_; i++) {
+        a = nextLine(a, nullptr);
+        if (a >= size_) return true;
+    }
+    return false;
+}
+
+void TextPager::down(int n) {
+    for (; n > 0 && !atEnd(); n--) top_ = nextLine(top_, nullptr);
+}
+
+void TextPager::up(int n) {
+    for (; n > 0 && top_ > 0; n--) top_ = lineBefore(top_);
+}
+
+void TextPager::toEnd() {
+    top_ = size_;
+    up(rows_);
+}
+
+std::vector<std::string> TextPager::lines() {
+    std::vector<std::string> out;
+    uint32_t a = top_;
+    for (int i = 0; i < rows_ && a < size_; i++) {
+        std::string text;
+        a = nextLine(a, &text);
+        out.push_back(std::move(text));
+    }
+    return out;
+}
+
+}  // namespace roro::files
@@ -0,0 +1,50 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace roro::files {
+
+// A text file of any size, shown a screen at a time (F1, Q134): only the part on screen is read,
+// through `read`, about a kilobyte at once. Lines wrap at spaces, `cols` characters wide. Going
+// back a line means finding where the paragraph before started and wrapping it again, so a file
+// reads the same whichever way it was scrolled.
+class TextPager {
+   public:
+    // Reads up to `len` bytes at `offset`; returns how many it got.
+    using ReadAt = std::function<size_t(uint32_t offset, uint8_t* into, size_t len)>;
+
+    TextPager(ReadAt read, uint32_t size, int cols, int rows);
+
+    void toStart() { top_ = 0; }
+    void toEnd();  // the last line at the bottom of the screen
+    void down(int lines = 1);
+    void up(int lines = 1);
+
+    std::vector<std::string> lines();  // what's on screen: tabs as spaces, control characters as dots
+    uint32_t top() const { return top_; }
+    uint32_t size() const { return size_; }
+    bool atEnd();  // the file's last line is on screen
+    int percent() const { return size_ ? static_cast<int>(static_cast<uint64_t>(top_) * 100 / size_) : 0; }
+
+   private:
+    static constexpr size_t kBlock = 1024;       // read at once
+    static constexpr uint32_t kLookBack = 1024;  // how far back a paragraph's start is looked for
+
+    const uint8_t* bytes(uint32_t at, size_t& len);  // what's cached from `at` on
+    int byteAt(uint32_t at);                         // -1 past the end
+    uint32_t nextLine(uint32_t at, std::string* text);  // where the line after the one at `at` starts
+    uint32_t lineBefore(uint32_t at);
+
+    ReadAt read_;
+    uint32_t size_;
+    int cols_, rows_;
+    uint32_t top_ = 0;
+    std::vector<uint8_t> cache_;
+    uint32_t cacheAt_ = 0;
+};
+
+}  // namespace roro::files
@@ -0,0 +1,46 @@
+#include "traffic.h"
+
+#include <atomic>
+#include <cstdio>
+
+namespace roro::net {
+
+namespace {
+constexpr size_t kUsers = static_cast<size_t>(User::Count);
+std::atomic<uint32_t> in_[kUsers], out_[kUsers];
+}  // namespace
+
+const char* userName(User user) {
+    switch (user) {
+        case User::Irc: return "IRC";
+        case User::Gemini: return "Gemini";
+        case User::DebugConsole: return "Debug Console";
+        case User::Updates: return "Updates";
+        default: return "?";
+    }
+}
+
+void received(User user, size_t bytes) { in_[static_cast<size_t>(user)] += static_cast<uint32_t>(bytes); }
+void sent(User user, size_t bytes) { out_[static_cast<size_t>(user)] += static_cast<uint32_t>(bytes); }
+Traffic traffic(User user) { return {in_[static_cast<size_t>(user)], out_[static_cast<size_t>(user)]}; }
+
+void resetTraffic() {
+    for (size_t i = 0; i < kUsers; i++) in_[i] = out_[i] = 0;
+}
+
+uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs) {
+    if (!elapsedMs) return 0;
+    return static_cast<uint32_t>(static_cast<uint64_t>(now - before) * 1000 / elapsedMs);  // wraps with the counter
+}
+
+std::string formatTraffic(uint32_t bytes) {
+    char s[16];
+    if (bytes < 1000) std::snprintf(s, sizeof s, "%u B", static_cast<unsigned>(bytes));
+    else if (bytes < 10 * 1024) std::snprintf(s, sizeof s, "%.1f KB", bytes / 1024.0);
+    else if (bytes < 1000 * 1024) std::snprintf(s, sizeof s, "%u KB", static_cast<unsigned>(bytes / 1024));
+    else if (bytes < 10u * 1024 * 1024) std::snprintf(s, sizeof s, "%.1f MB", bytes / 1048576.0);
+    else std::snprintf(s, sizeof s, "%u MB", static_cast<unsigned>(bytes / 1048576));
+    return s;
+}
+
+}  // namespace roro::net
@@ -0,0 +1,26 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace roro::net {
+
+// Bytes each network service has read and written since boot (S1, Q121), as the service sees
+// them: for TLS connections that's the plain text, without the handshake or record overhead.
+// Counted from the services' own tasks, read from the main loop.
+enum class User : uint8_t { Irc, Gemini, DebugConsole, Updates, Count };
+const char* userName(User user);
+
+struct Traffic {
+    uint32_t in = 0, out = 0;
+};
+void received(User user, size_t bytes);
+void sent(User user, size_t bytes);
+Traffic traffic(User user);
+void resetTraffic();  // for tests
+
+uint32_t bytesPerSecond(uint32_t before, uint32_t now, uint32_t elapsedMs);
+std::string formatTraffic(uint32_t bytes);  // "999 B", "1.5 KB", "12 KB", "1.7 MB"
+
+}  // namespace roro::net
@@ -0,0 +1,329 @@
+#include "note_text.h"
+
+#include <algorithm>
+
+namespace roro::notes {
+
+namespace {
+bool continuation(char c) { return (static_cast<uint8_t>(c) & 0xC0) == 0x80; }
+}  // namespace
+
+NoteText::NoteText(int cols, int rows) : cols_(std::max(1, cols)), rows_(std::max(1, rows)) { text_.reserve(kMaxBytes); }
+
+NoteText::NoteText(int cols, int rows, std::string&& text) : cols_(std::max(1, cols)), rows_(std::max(1, rows)), text_(std::move(text)) {
+    dropCarriageReturns();
+    if (text_.size() > kMaxBytes) text_.resize(kMaxBytes);  // the caller checks sizes: not reached
+    text_.reserve(kMaxBytes);
+}
+
+void NoteText::dropCarriageReturns() {
+    size_t kept = 0;
+    for (size_t i = 0; i < text_.size(); i++)
+        if (!(text_[i] == '\r' && i + 1 < text_.size() && text_[i + 1] == '\n')) text_[kept++] = text_[i];
+    text_.resize(kept);
+}
+
+bool NoteText::setText(const std::string& text) {
+    size_t kept = text.size();
+    for (size_t i = 0; i + 1 < text.size(); i++)
+        if (text[i] == '\r' && text[i + 1] == '\n') kept--;
+    if (kept > kMaxBytes) return false;
+    text_.assign(text);
+    dropCarriageReturns();
+    cursor_ = top_ = 0;
+    goal_ = -1;
+    revision_++;
+    return true;
+}
+
+size_t NoteText::nextLine(size_t start) const {
+    size_t size = text_.size();
+    int count = 0;
+    size_t lastSpace = 0;
+    bool space = false;
+    for (size_t i = start; i < size; i++) {
+        char c = text_[i];
+        if (c == '\n') return i + 1;
+        if (continuation(c)) continue;
+        if (count == cols_) {  // one character too many: wrap
+            if (c == ' ') return i + 1;       // the space stays at the end of this line
+            if (space) return lastSpace + 1;  // after the last space that fits
+            return i;                         // a word longer than the screen is cut
+        }
+        count++;
+        if (c == ' ') {
+            lastSpace = i;
+            space = true;
+        }
+    }
+    return size;
+}
+
+size_t NoteText::lineOf(size_t pos) const {
+    size_t size = text_.size();
+    pos = std::min(pos, size);
+    size_t a = pos;  // the start of the paragraph: after the newline before `pos`
+    while (a > 0 && text_[a - 1] != '\n') a--;
+    while (a < size) {
+        size_t n = nextLine(a);
+        if (n > pos) return a;
+        // The end of the text is on the last line, unless that line ended with a newline: then
+        // it's on an empty line of its own.
+        if (n == size && pos == size && text_[size - 1] != '\n') return a;
+        a = n;
+    }
+    return a;
+}
+
+bool NoteText::hasLineAfter(size_t start) const {
+    size_t n = nextLine(start), size = text_.size();
+    if (n < size) return true;
+    return start < size && lineOf(size) != start;  // the empty line after a final newline
+}
+
+size_t NoteText::lastSpot(size_t start) const {
+    size_t n = nextLine(start), size = text_.size();
+    if (n == start) return start;  // the empty line at the end
+    if (n == size && lineOf(size) == start) return size;
+    size_t p = n - 1;  // before the newline, the space or the last character the line ends with
+    while (p > start && continuation(text_[p])) p--;
+    return p;
+}
+
+int NoteText::columnOf(size_t start, size_t pos) const {
+    int col = 0;
+    for (size_t i = start; i < pos && i < text_.size(); i++)
+        if (!continuation(text_[i])) col++;
+    return col;
+}
+
+size_t NoteText::atColumn(size_t start, int col) const {
+    size_t last = lastSpot(start), p = start;
+    while (p < last && col > 0) {
+        p++;
+        while (p < last && continuation(text_[p])) p++;
+        col--;
+    }
+    return p;
+}
+
+void NoteText::moved(bool keepGoal) {
+    if (!keepGoal) goal_ = -1;
+}
+
+bool NoteText::insertText(const std::string& s) {
+    if (text_.size() + s.size() > kMaxBytes) return false;
+    text_.insert(cursor_, s);
+    cursor_ += s.size();
+    revision_++;
+    moved();
+    return true;
+}
+
+bool NoteText::insert(uint32_t cp) {
+    std::string s;
+    if (cp < 0x80) s += static_cast<char>(cp);
+    else if (cp < 0x800) {
+        s += static_cast<char>(0xC0 | (cp >> 6));
+        s += static_cast<char>(0x80 | (cp & 0x3F));
+    } else if (cp < 0x10000) {
+        s += static_cast<char>(0xE0 | (cp >> 12));
+        s += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+        s += static_cast<char>(0x80 | (cp & 0x3F));
+    } else {
+        s += static_cast<char>(0xF0 | (cp >> 18));
+        s += static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+        s += static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+        s += static_cast<char>(0x80 | (cp & 0x3F));
+    }
+    return insertText(s);
+}
+
+void NoteText::backspace() {
+    if (cursor_ == 0) return;
+    size_t from = cursor_ - 1;
+    while (from > 0 && continuation(text_[from])) from--;
+    text_.erase(from, cursor_ - from);
+    cursor_ = from;
+    revision_++;
+    moved();
+}
+
+void NoteText::left() {
+    if (cursor_ == 0) return;
+    cursor_--;
+    while (cursor_ > 0 && continuation(text_[cursor_])) cursor_--;
+    moved();
+}
+
+void NoteText::right() {
+    if (cursor_ >= text_.size()) return;
+    cursor_++;
+    while (cursor_ < text_.size() && continuation(text_[cursor_])) cursor_++;
+    moved();
+}
+
+void NoteText::up() {
+    size_t line = lineOf(cursor_);
+    if (goal_ < 0) goal_ = columnOf(line, cursor_);
+    if (line == 0) return;
+    cursor_ = atColumn(lineOf(line - 1), goal_);
+    moved(true);
+}
+
+void NoteText::down() {
+    size_t line = lineOf(cursor_);
+    if (goal_ < 0) goal_ = columnOf(line, cursor_);
+    if (!hasLineAfter(line)) return;
+    size_t next = nextLine(line);
+    cursor_ = next >= text_.size() ? text_.size() : atColumn(next, goal_);
+    moved(true);
+}
+
+void NoteText::pageUp() {
+    for (int i = 1; i < rows_; i++) up();
+}
+
+void NoteText::pageDown() {
+    for (int i = 1; i < rows_; i++) down();
+}
+
+void NoteText::lineStart() {
+    cursor_ = lineOf(cursor_);
+    moved();
+}
+
+void NoteText::lineEnd() {
+    cursor_ = lastSpot(lineOf(cursor_));
+    moved();
+}
+
+void NoteText::toStart() {
+    cursor_ = 0;
+    moved();
+}
+
+void NoteText::toEnd() {
+    cursor_ = text_.size();
+    moved();
+}
+
+void NoteText::follow() {
+    size_t line = lineOf(cursor_);
+    top_ = lineOf(std::min(top_, text_.size()));  // an edit above may have moved where lines start
+    if (line < top_) {
+        top_ = line;
+        return;
+    }
+    size_t a = top_;
+    for (int i = 0; i < rows_; i++) {
+        if (a == line) return;  // on screen
+        if (!hasLineAfter(a)) return;
+        a = nextLine(a);
+    }
+    // Below the screen: the cursor's line becomes the last row.
+    top_ = line;
+    for (int i = 1; i < rows_ && top_ > 0; i++) top_ = lineOf(top_ - 1);
+}
+
+std::vector<std::string> NoteText::rows() {
+    follow();
+    std::vector<std::string> out;
+    size_t a = top_, size = text_.size();
+    for (int i = 0; i < rows_; i++) {
+        size_t n = nextLine(a);
+        std::string row = text_.substr(a, n - a);
+        if (!row.empty() && row.back() == '\n') row.pop_back();
+        for (char& c : row)
+            if (c == '\t') c = ' ';
+        out.push_back(std::move(row));
+        if (!hasLineAfter(a)) break;
+        a = n >= size ? size : n;
+    }
+    return out;
+}
+
+int NoteText::cursorRow() {
+    follow();
+    size_t line = lineOf(cursor_), a = top_;
+    for (int i = 0; i < rows_; i++) {
+        if (a == line) return i;
+        a = nextLine(a);
+    }
+    return rows_ - 1;
+}
+
+int NoteText::cursorCol() { return columnOf(lineOf(cursor_), cursor_); }
+
+// At most a screen's worth of it: a note that is one line of 16 KB must not be copied whole.
+std::string NoteText::firstLine() const { return text_.substr(0, std::min<size_t>(text_.find('\n'), 160)); }
+
+namespace {
+// U+00C0 to U+00FF as the plain letters a file name gets; 0: left out.
+const char kPlain[64] = {
+    'a', 'a', 'a', 'a', 'a', 'a', 0,   'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i',   // À..Ï
+    0,   'n', 'o', 'o', 'o', 'o', 'o', 0,   'o', 'u', 'u', 'u', 'u', 'y', 0,   's',   // Ð..ß
+    'a', 'a', 'a', 'a', 'a', 'a', 0,   'c', 'e', 'e', 'e', 'e', 'i', 'i', 'i', 'i',   // à..ï
+    0,   'n', 'o', 'o', 'o', 'o', 'o', 0,   'o', 'u', 'u', 'u', 'u', 'y', 0,   'y'};  // ð..ÿ
+
+// Drops a character the end of the string cuts in two.
+void dropPartial(std::string& s) {
+    size_t k = s.size();
+    while (k > 0 && continuation(s[k - 1]) && s.size() - k < 3) k--;
+    if (k == 0) return;
+    uint8_t lead = static_cast<uint8_t>(s[k - 1]);
+    size_t want = lead >= 0xF0 ? 4 : lead >= 0xE0 ? 3 : lead >= 0xC0 ? 2 : 1;
+    if (s.size() - (k - 1) < want) s.resize(k - 1);
+}
+}  // namespace
+
+std::string nameFromFirstLine(const std::string& firstLine, const std::string& stamp) {
+    std::string out;
+    bool dash = false;
+    for (size_t i = 0; i < firstLine.size() && out.size() < 32; i++) {
+        uint8_t c = static_cast<uint8_t>(firstLine[i]);
+        char letter = 0;
+        if (c < 0x80) {
+            if (c >= 'A' && c <= 'Z') letter = static_cast<char>(c + 32);
+            else if ((c >= 'a' && c <= 'z') || (c >= '0' && c <= '9')) letter = static_cast<char>(c);
+        } else if (c == 0xC3 && i + 1 < firstLine.size()) {  // U+00C0..U+00FF
+            letter = kPlain[static_cast<uint8_t>(firstLine[++i]) & 0x3F];
+        } else {
+            while (i + 1 < firstLine.size() && continuation(firstLine[i + 1])) i++;  // anything else is left out
+        }
+        if (letter) {
+            if (dash && !out.empty()) out += '-';
+            dash = false;
+            out += letter;
+        } else {
+            dash = true;
+        }
+    }
+    return out.empty() ? "note-" + stamp : out;
+}
+
+std::string titleFrom(const std::string& head, size_t maxChars) {
+    for (size_t at = 0; at < head.size();) {
+        size_t end = head.find('\n', at);
+        bool cut = end == std::string::npos;  // the line goes on past what was read
+        if (cut) end = head.size();
+        std::string line = head.substr(at, end - at);
+        if (cut) dropPartial(line);
+        while (!line.empty() && (line.back() == '\r' || line.back() == ' ' || line.back() == '\t')) line.pop_back();
+        size_t first = line.find_first_not_of(" \t");
+        if (first != std::string::npos) {
+            line.erase(0, first);
+            size_t bytes = 0;
+            for (size_t chars = 0; bytes < line.size() && chars < maxChars; chars++) {
+                bytes++;
+                while (bytes < line.size() && continuation(line[bytes])) bytes++;
+            }
+            line.resize(bytes);
+            return line;
+        }
+        at = end + 1;
+    }
+    return "";
+}
+
+}  // namespace roro::notes
@@ -0,0 +1,81 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+#include <vector>
+
+namespace roro::notes {
+
+// The text of a note while it's edited (F1, Q144, Q145): UTF-8 held whole in memory, a cursor, and
+// the part of it on screen. Lines wrap at spaces, `cols` characters wide; a line owns the space or
+// the newline it ends with, so every byte of the text belongs to exactly one line. No index of
+// lines is kept (a note of newlines alone would need twice its size): where a line starts is
+// worked out from the start of its paragraph, which is never far.
+class NoteText {
+   public:
+    static constexpr size_t kMaxBytes = 16 * 1024;
+
+    // Room for a full note is reserved once, so typing never has to find a bigger block of memory:
+    // on the device a failed allocation is the end. The second form takes over a string the
+    // caller filled (and reserved): a note is never in memory twice.
+    NoteText(int cols, int rows);
+    NoteText(int cols, int rows, std::string&& text);
+
+    // Copied into the buffer already held. CRLF becomes LF (Q148). False, and nothing changes, if
+    // it's over kMaxBytes.
+    bool setText(const std::string& text);
+    const std::string& text() const { return text_; }
+    size_t cursor() const { return cursor_; }
+    uint32_t revision() const { return revision_; }  // changes with every edit: is it saved?
+
+    bool insert(uint32_t codePoint);         // false: the note is full
+    bool insertText(const std::string& s);   // all of it or nothing
+    void backspace();
+    void left();
+    void right();
+    void up();
+    void down();
+    void pageUp();
+    void pageDown();
+    void lineStart();
+    void lineEnd();
+    void toStart();
+    void toEnd();
+
+    // The screen, kept around the cursor: its rows (tabs as spaces, the ending newline left out),
+    // and where the cursor is on it, in rows and characters.
+    std::vector<std::string> rows();
+    int cursorRow();
+    int cursorCol();
+    int percent() const { return text_.empty() ? 0 : static_cast<int>(top_ * 100 / text_.size()); }
+
+    std::string firstLine() const;  // without its newline, for the title and the file's name
+
+   private:
+    size_t nextLine(size_t start) const;       // where the line after the one at `start` starts
+    size_t lineOf(size_t pos) const;           // the start of the line `pos` is on
+    size_t lastSpot(size_t start) const;       // the last place the cursor can be on that line
+    size_t atColumn(size_t start, int col) const;
+    int columnOf(size_t start, size_t pos) const;
+    bool hasLineAfter(size_t start) const;
+    void moved(bool keepGoal = false);
+    void follow();  // scrolls so the cursor is on screen
+    void dropCarriageReturns();
+
+    int cols_, rows_;
+    std::string text_;
+    size_t cursor_ = 0, top_ = 0;
+    int goal_ = -1;  // the column Up and Down aim for, across short lines
+    uint32_t revision_ = 0;
+};
+
+// The file a new note is saved as (Q142): from its first line, "Shopping list!" -> "shopping-list",
+// or "note-<stamp>" when that gives nothing. No extension, no folder.
+std::string nameFromFirstLine(const std::string& firstLine, const std::string& stamp);
+
+// A row's title in the Notes list, from the first bytes of a file: its first line that isn't
+// blank, cut to `maxChars`; "" if there's none.
+std::string titleFrom(const std::string& head, size_t maxChars);
+
+}  // namespace roro::notes
@@ -0,0 +1,158 @@
+#include "http_head.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstdlib>
+
+namespace roro::release {
+
+namespace {
+std::string lower(std::string s) {
+    for (char& c : s) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+    return s;
+}
+}  // namespace
+
+size_t HttpHeadParser::feed(const char* data, size_t len) {
+    size_t used = 0;
+    while (used < len && !complete_ && !failed_) {
+        char c = data[used++];
+        total_++;
+        if (total_ > kMaxBytes) {
+            failed_ = true;
+            break;
+        }
+        if (c == '\n') {
+            if (!line_.empty() && line_.back() == '\r') line_.pop_back();
+            line();
+            line_.clear();
+        } else {
+            line_ += c;
+        }
+    }
+    return used;
+}
+
+void HttpHeadParser::line() {
+    if (first_) {  // "HTTP/1.1 200 OK"
+        first_ = false;
+        if (line_.compare(0, 5, "HTTP/") != 0) {
+            failed_ = true;
+            return;
+        }
+        size_t space = line_.find(' ');
+        head_.status = space == std::string::npos ? 0 : std::atoi(line_.c_str() + space + 1);
+        if (head_.status < 100 || head_.status > 599) failed_ = true;
+        return;
+    }
+    if (line_.empty()) {
+        complete_ = true;
+        return;
+    }
+    size_t colon = line_.find(':');
+    if (colon == std::string::npos) return;  // not a header: ignored
+    std::string name = lower(line_.substr(0, colon));
+    size_t from = line_.find_first_not_of(" \t", colon + 1);
+    std::string value = from == std::string::npos ? "" : line_.substr(from);
+    if (name == "content-length") head_.contentLength = std::atol(value.c_str());
+    else if (name == "transfer-encoding") head_.chunked = lower(value).find("chunked") != std::string::npos;
+    else if (name == "location") head_.location = value;
+    else if (name == "content-type") head_.contentType = value;
+}
+
+size_t ChunkedDecoder::decode(const uint8_t* in, size_t len, uint8_t* out) {
+    size_t written = 0;
+    for (size_t i = 0; i < len && !failed_ && state_ != State::Done; i++) {
+        uint8_t c = in[i];
+        switch (state_) {
+            case State::Size: {
+                int digit = c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
+                if (digit >= 0) {
+                    if (remaining_ > (SIZE_MAX >> 5)) failed_ = true;
+                    remaining_ = remaining_ * 16 + digit;
+                    anyDigit_ = true;
+                } else if (c == ';' && anyDigit_) {
+                    state_ = State::Extension;
+                } else if (c == '\r' && anyDigit_) {
+                    state_ = State::SizeLf;
+                } else {
+                    failed_ = true;
+                }
+                break;
+            }
+            case State::Extension:
+                if (c == '\r') state_ = State::SizeLf;
+                break;
+            case State::SizeLf:
+                if (c != '\n') {
+                    failed_ = true;
+                } else if (remaining_ == 0) {
+                    state_ = State::Trailer;
+                    trailerLine_ = 0;
+                } else {
+                    state_ = State::Data;
+                }
+                break;
+            case State::Data: {
+                size_t take = std::min(remaining_, len - i);
+                for (size_t k = 0; k < take; k++) out[written + k] = in[i + k];
+                written += take;
+                remaining_ -= take;
+                i += take - 1;
+                if (remaining_ == 0) state_ = State::DataCr;
+                break;
+            }
+            case State::DataCr:
+                if (c != '\r') failed_ = true;
+                else state_ = State::DataLf;
+                break;
+            case State::DataLf:
+                if (c != '\n') {
+                    failed_ = true;
+                } else {
+                    state_ = State::Size;
+                    anyDigit_ = false;
+                }
+                break;
+            case State::Trailer:  // header lines after the last chunk, until an empty one
+                if (c == '\n') {
+                    if (trailerLine_ == 0) state_ = State::Done;
+                    trailerLine_ = 0;
+                } else if (c != '\r') {
+                    trailerLine_++;
+                }
+                break;
+            case State::Done: break;
+        }
+    }
+    return written;
+}
+
+Url parseUrl(const std::string& url) {
+    Url u;
+    size_t scheme = url.find("://");
+    if (scheme == std::string::npos) return u;
+    std::string s = lower(url.substr(0, scheme));
+    if (s != "http" && s != "https") return u;
+    u.https = s == "https";
+    size_t hostStart = scheme + 3, pathStart = url.find('/', hostStart);
+    std::string authority = url.substr(hostStart, pathStart == std::string::npos ? std::string::npos : pathStart - hostStart);
+    u.path = pathStart == std::string::npos ? "/" : url.substr(pathStart);
+    if (authority.empty() || authority.find('@') != std::string::npos) return u;  // no credentials in a URL
+    size_t colon = authority.rfind(':');
+    u.port = u.https ? 443 : 80;
+    if (colon != std::string::npos) {
+        u.port = std::atoi(authority.c_str() + colon + 1);
+        authority.resize(colon);
+        if (u.port <= 0 || u.port > 65535) return u;
+    }
+    for (unsigned char c : authority)
+        if (!(std::isalnum(c) || c == '.' || c == '-')) return u;
+    for (unsigned char c : u.path)
+        if (c <= ' ' || c == 0x7F) return u;
+    u.host = lower(authority);
+    u.ok = !u.host.empty();
+    return u;
+}
+
+}  // namespace roro::release
@@ -0,0 +1,62 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <string>
+
+namespace roro::release {
+
+// The status line and headers of an HTTP/1.1 response, read as bytes arrive.
+struct HttpHead {
+    int status = 0;
+    long contentLength = -1;  // -1: not given
+    bool chunked = false;
+    std::string location, contentType;
+};
+
+class HttpHeadParser {
+   public:
+    static constexpr size_t kMaxBytes = 4096;
+
+    // Takes bytes up to and including the blank line that ends the head; returns how many it used.
+    // What follows is the body.
+    size_t feed(const char* data, size_t len);
+    bool complete() const { return complete_; }
+    bool failed() const { return failed_; }
+    const HttpHead& head() const { return head_; }
+
+   private:
+    void line();
+
+    HttpHead head_;
+    std::string line_;
+    size_t total_ = 0;
+    bool first_ = true, complete_ = false, failed_ = false;
+};
+
+// Takes the chunks of "Transfer-Encoding: chunked" apart as they arrive.
+class ChunkedDecoder {
+   public:
+    // `out` has room for `len` bytes (the body is never longer than what carried it).
+    size_t decode(const uint8_t* in, size_t len, uint8_t* out);
+    bool done() const { return state_ == State::Done; }
+    bool failed() const { return failed_; }
+
+   private:
+    enum class State : uint8_t { Size, Extension, SizeLf, Data, DataCr, DataLf, Trailer, Done };
+    State state_ = State::Size;
+    size_t remaining_ = 0;
+    bool anyDigit_ = false, failed_ = false;
+    size_t trailerLine_ = 0;
+};
+
+// "https://git.twis.la/twisla/x/releases/download/v1/a.ota" taken apart. Only http and https.
+struct Url {
+    bool ok = false;
+    bool https = false;
+    std::string host, path;  // path from the first "/", with its query; "/" if none
+    int port = 0;
+};
+Url parseUrl(const std::string& url);
+
+}  // namespace roro::release
@@ -0,0 +1,202 @@
+#include "json_scan.h"
+
+namespace roro::release {
+
+namespace {
+bool space(char c) { return c == ' ' || c == '\t' || c == '\r' || c == '\n'; }
+bool continuation(char c) { return (static_cast<uint8_t>(c) & 0xC0) == 0x80; }
+}  // namespace
+
+void JsonScanner::feed(const char* data, size_t len) {
+    for (size_t i = 0; i < len && !failed_; i++) step(data[i]);
+}
+
+std::string JsonScanner::path() const {
+    std::string p;
+    for (const Frame& f : stack_) {
+        if (f.isObject) {
+            if (!p.empty()) p += '.';
+            p += f.key;
+        } else {
+            p += '[' + std::to_string(f.index) + ']';
+        }
+    }
+    return p;
+}
+
+void JsonScanner::append(const char* bytes, size_t n) {
+    if (text_.size() + n > max_) {
+        truncated_ = true;
+        return;
+    }
+    text_.append(bytes, n);
+}
+
+void JsonScanner::appendCodePoint(uint32_t cp) {
+    char b[4];
+    size_t n;
+    if (cp < 0x80) {
+        b[0] = static_cast<char>(cp);
+        n = 1;
+    } else if (cp < 0x800) {
+        b[0] = static_cast<char>(0xC0 | (cp >> 6));
+        b[1] = static_cast<char>(0x80 | (cp & 0x3F));
+        n = 2;
+    } else if (cp < 0x10000) {
+        b[0] = static_cast<char>(0xE0 | (cp >> 12));
+        b[1] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+        b[2] = static_cast<char>(0x80 | (cp & 0x3F));
+        n = 3;
+    } else {
+        b[0] = static_cast<char>(0xF0 | (cp >> 18));
+        b[1] = static_cast<char>(0x80 | ((cp >> 12) & 0x3F));
+        b[2] = static_cast<char>(0x80 | ((cp >> 6) & 0x3F));
+        b[3] = static_cast<char>(0x80 | (cp & 0x3F));
+        n = 4;
+    }
+    append(b, n);
+}
+
+void JsonScanner::startString(bool key) {
+    inString_ = true;
+    isKey_ = key;
+    escape_ = false;
+    unicodeLeft_ = 0;
+    highSurrogate_ = 0;
+    truncated_ = false;
+    text_.clear();
+}
+
+void JsonScanner::stringChar(char c) {
+    if (unicodeLeft_ > 0) {
+        int digit = c >= '0' && c <= '9' ? c - '0' : c >= 'a' && c <= 'f' ? c - 'a' + 10 : c >= 'A' && c <= 'F' ? c - 'A' + 10 : -1;
+        if (digit < 0) return fail();
+        unicode_ = unicode_ * 16 + digit;
+        if (--unicodeLeft_ == 0) {
+            if (unicode_ >= 0xD800 && unicode_ < 0xDC00) {
+                highSurrogate_ = unicode_;  // the low half comes next
+            } else if (unicode_ >= 0xDC00 && unicode_ < 0xE000 && highSurrogate_) {
+                appendCodePoint(0x10000 + ((highSurrogate_ - 0xD800) << 10) + (unicode_ - 0xDC00));
+                highSurrogate_ = 0;
+            } else {
+                appendCodePoint(unicode_);
+                highSurrogate_ = 0;
+            }
+        }
+        return;
+    }
+    if (escape_) {
+        escape_ = false;
+        switch (c) {
+            case 'n': append("\n", 1); break;
+            case 't': append("\t", 1); break;
+            case 'r': append("\r", 1); break;
+            case 'b': append("\b", 1); break;
+            case 'f': append("\f", 1); break;
+            case 'u': unicodeLeft_ = 4; unicode_ = 0; break;
+            default: append(&c, 1); break;  // \" \\ \/
+        }
+        return;
+    }
+    if (c == '\\') {
+        escape_ = true;
+    } else if (c == '"') {
+        endString();
+    } else {
+        append(&c, 1);
+    }
+}
+
+void JsonScanner::endString() {
+    inString_ = false;
+    // A cut can leave half a character at the end.
+    while (truncated_ && !text_.empty()) {
+        size_t k = text_.size();
+        while (k > 0 && continuation(text_[k - 1])) k--;
+        if (k == 0) break;
+        uint8_t lead = static_cast<uint8_t>(text_[k - 1]);
+        size_t want = lead >= 0xF0 ? 4 : lead >= 0xE0 ? 3 : lead >= 0xC0 ? 2 : 1;
+        if (text_.size() - (k - 1) < want) text_.resize(k - 1);
+        break;
+    }
+    if (isKey_) {
+        stack_.back().key = text_;
+        expect_ = Expect::Colon;
+        return;
+    }
+    sink_(path(), text_, true, truncated_);
+    valueDone();
+}
+
+void JsonScanner::endLiteral() {
+    inLiteral_ = false;
+    sink_(path(), text_, false, false);
+    valueDone();
+}
+
+void JsonScanner::valueDone() {
+    if (stack_.empty()) {
+        done_ = true;
+        return;
+    }
+    expect_ = Expect::CommaOrEnd;
+}
+
+void JsonScanner::step(char c) {
+    if (inString_) return stringChar(c);
+    if (inLiteral_) {
+        if (space(c) || c == ',' || c == '}' || c == ']') {
+            endLiteral();  // and the character that ended it is read again below
+        } else {
+            if (text_.size() < max_) text_ += c;
+            return;
+        }
+    }
+    if (space(c)) return;
+    switch (expect_) {
+        case Expect::Value:
+            if (c == '{') {
+                stack_.push_back({true, "", 0});
+                expect_ = Expect::KeyOrEnd;
+            } else if (c == '[') {
+                stack_.push_back({false, "", 0});
+                expect_ = Expect::Value;
+            } else if (c == ']' && !stack_.empty() && !stack_.back().isObject && stack_.back().index == 0) {
+                stack_.pop_back();  // an empty array
+                valueDone();
+            } else if (c == '"') {
+                startString(false);
+            } else if (c == '-' || (c >= '0' && c <= '9') || c == 't' || c == 'f' || c == 'n') {
+                inLiteral_ = true;
+                text_.assign(1, c);
+            } else {
+                fail();
+            }
+            return;
+        case Expect::KeyOrEnd:
+            if (c == '"') startString(true);
+            else if (c == '}') {
+                stack_.pop_back();
+                valueDone();
+            } else fail();
+            return;
+        case Expect::Colon:
+            if (c == ':') expect_ = Expect::Value;
+            else fail();
+            return;
+        case Expect::CommaOrEnd:
+            if (c == ',') {
+                if (stack_.back().isObject) expect_ = Expect::KeyOrEnd;
+                else {
+                    stack_.back().index++;
+                    expect_ = Expect::Value;
+                }
+            } else if ((c == '}' && stack_.back().isObject) || (c == ']' && !stack_.back().isObject)) {
+                stack_.pop_back();
+                valueDone();
+            } else fail();
+            return;
+    }
+}
+
+}  // namespace roro::release
@@ -0,0 +1,57 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <functional>
+#include <string>
+#include <vector>
+
+namespace roro::release {
+
+// Reads JSON as it arrives, a chunk at a time, and reports each plain value (a string, a number,
+// true, false, null) with where it was found: "tag_name", "assets[1].name", "[2].draft". Nothing
+// is kept but the path, so a 33 KB list of releases costs a few hundred bytes. A value longer than
+// `maxValueBytes` is cut (never in the middle of a character) and reported as truncated.
+// Meant for a server's answer, not for validating JSON: it only refuses what it can't follow.
+class JsonScanner {
+   public:
+    using Sink = std::function<void(const std::string& path, const std::string& value, bool isString, bool truncated)>;
+
+    explicit JsonScanner(Sink sink, size_t maxValueBytes = 300) : sink_(std::move(sink)), max_(maxValueBytes) {}
+
+    void feed(const char* data, size_t len);
+    bool failed() const { return failed_; }
+    bool done() const { return done_ && !failed_; }  // the top-level value is complete
+
+   private:
+    enum class Expect : uint8_t { Value, KeyOrEnd, Colon, CommaOrEnd };
+    struct Frame {
+        bool isObject;
+        std::string key;
+        int index;
+    };
+
+    void step(char c);
+    void startString(bool key);
+    void stringChar(char c);
+    void appendCodePoint(uint32_t cp);
+    void endString();
+    void endLiteral();
+    void valueDone();
+    void append(const char* bytes, size_t n);
+    std::string path() const;
+    void fail() { failed_ = true; }
+
+    Sink sink_;
+    size_t max_;
+    std::vector<Frame> stack_;
+    Expect expect_ = Expect::Value;
+    bool inString_ = false, isKey_ = false, escape_ = false, inLiteral_ = false;
+    int unicodeLeft_ = 0;
+    uint32_t unicode_ = 0, highSurrogate_ = 0;
+    bool truncated_ = false;
+    std::string text_;
+    bool failed_ = false, done_ = false;
+};
+
+}  // namespace roro::release
@@ -0,0 +1,80 @@
+#include "release_info.h"
+
+#include <cstdlib>
+
+namespace roro::release {
+
+namespace {
+bool endsWith(const std::string& s, const char* tail) {
+    size_t n = std::char_traits<char>::length(tail);
+    return s.size() >= n && s.compare(s.size() - n, n, tail) == 0;
+}
+}  // namespace
+
+std::string firstParagraph(const std::string& text, bool truncated) {
+    size_t end = text.find("\n\n");
+    size_t crlf = text.find("\r\n\r\n");
+    if (crlf != std::string::npos && (end == std::string::npos || crlf < end)) end = crlf;
+    std::string p = text.substr(0, end);
+    size_t first = p.find_first_not_of(" \t\r\n");
+    if (first == std::string::npos) return "";
+    p.erase(0, first);
+    while (!p.empty() && (p.back() == ' ' || p.back() == '\t' || p.back() == '\r' || p.back() == '\n')) p.pop_back();
+    if (truncated && end == std::string::npos) p += "...";
+    return p;
+}
+
+ReleaseReader::ReleaseReader(size_t maxReleases)
+    : scanner_([this](const std::string& path, const std::string& text, bool isString, bool truncated) {
+          value(path, text, isString, truncated);
+      }),
+      max_(maxReleases) {}
+
+void ReleaseReader::end() { flushAsset(); }
+
+void ReleaseReader::flushAsset() {
+    if (assetRelease_ >= 0 && assetRelease_ < static_cast<int>(releases_.size()) && endsWith(assetName_, ".ota") && !assetUrl_.empty()) {
+        releases_[assetRelease_].otaUrl = assetUrl_;
+        releases_[assetRelease_].otaSize = assetSize_;
+    }
+    assetRelease_ = assetIndex_ = -1;
+    assetName_.clear();
+    assetUrl_.clear();
+    assetSize_ = 0;
+}
+
+void ReleaseReader::value(const std::string& path, const std::string& text, bool isString, bool truncated) {
+    size_t index = 0;
+    std::string rest = path;
+    if (!path.empty() && path[0] == '[') {  // a list: "[2].tag_name"
+        char* end;
+        index = static_cast<size_t>(std::strtol(path.c_str() + 1, &end, 10));
+        rest = *end == ']' ? std::string(end + 1) : "";
+        if (!rest.empty() && rest[0] == '.') rest.erase(0, 1);
+    }
+    if (index >= max_) return;
+    if (releases_.size() <= index) releases_.resize(index + 1);
+    Release& r = releases_[index];
+
+    if (rest == "tag_name") r.tag = text;
+    else if (rest == "published_at") r.published = text;
+    else if (rest == "body") r.notes = firstParagraph(text, truncated);
+    else if (rest == "draft") r.draft = text == "true";
+    else if (rest == "prerelease") r.prerelease = text == "true";
+    else if (rest.compare(0, 7, "assets[") == 0) {
+        char* end;
+        int j = static_cast<int>(std::strtol(rest.c_str() + 7, &end, 10));
+        if (static_cast<int>(index) != assetRelease_ || j != assetIndex_) {
+            flushAsset();
+            assetRelease_ = static_cast<int>(index);
+            assetIndex_ = j;
+        }
+        std::string field = *end == ']' && end[1] == '.' ? std::string(end + 2) : "";
+        if (field == "name") assetName_ = text;
+        else if (field == "size") assetSize_ = static_cast<uint32_t>(std::strtoul(text.c_str(), nullptr, 10));
+        else if (field == "browser_download_url") assetUrl_ = text;
+    }
+    (void)isString;
+}
+
+}  // namespace roro::release
@@ -0,0 +1,52 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "json_scan.h"
+
+namespace roro::release {
+
+// What the device needs to know about one Gitea release (docs/milestones/R1.md, #6).
+struct Release {
+    std::string tag;        // "v0.10.0"
+    std::string published;  // "2026-10-06T08:11:31Z"
+    std::string notes;      // the first paragraph of the text: the tag's message
+    std::string otaUrl;     // where the signed Update File is
+    uint32_t otaSize = 0;
+    bool draft = false, prerelease = false;
+
+    // Something that can be installed and that the project meant to publish (drafts and
+    // pre-releases are left out for now: a release channel is #53).
+    bool usable() const { return !draft && !prerelease && !tag.empty() && !otaUrl.empty(); }
+    std::string date() const { return published.substr(0, 10); }  // "2026-10-06"
+};
+
+// Reads Gitea's answer as it arrives: `releases/latest` (one object) or `releases?limit=N` (a list).
+class ReleaseReader {
+   public:
+    explicit ReleaseReader(size_t maxReleases = 10);
+
+    void feed(const char* data, size_t len) { scanner_.feed(data, len); }
+    void end();  // after the last chunk
+    bool ok() const { return !scanner_.failed(); }
+    bool complete() const { return scanner_.done(); }
+    const std::vector<Release>& releases() const { return releases_; }
+
+   private:
+    void value(const std::string& path, const std::string& text, bool isString, bool truncated);
+    void flushAsset();
+
+    JsonScanner scanner_;
+    size_t max_;
+    std::vector<Release> releases_;
+    int assetRelease_ = -1, assetIndex_ = -1;
+    std::string assetName_, assetUrl_;
+    uint32_t assetSize_ = 0;
+};
+
+// The first paragraph of a release's text, trimmed; "..." if the text was cut before it ended.
+std::string firstParagraph(const std::string& text, bool truncated);
+
+}  // namespace roro::release
@@ -0,0 +1,15 @@
+#include "update_check.h"
+
+#include "http_head.h"
+
+namespace roro::release {
+
+bool trustedAssetUrl(const std::string& url, const std::string& host, const std::string& repo) {
+    Url u = parseUrl(url);
+    if (!u.ok || !u.https || u.port != 443 || u.host != host) return false;
+    std::string prefix = "/" + repo + "/releases/download/";
+    return u.path.compare(0, prefix.size(), prefix) == 0 && u.path.find("..") == std::string::npos &&
+           u.path.find('?') == std::string::npos && u.path.find('#') == std::string::npos;
+}
+
+}  // namespace roro::release
@@ -0,0 +1,38 @@
+#pragma once
+
+#include <string>
+
+#include "release_info.h"
+#include "version_compare.h"
+
+namespace roro::release {
+
+// Where the project's releases are (Q164). A fork changes these, and its own signing key.
+constexpr const char* kGiteaHost = "git.twis.la";
+constexpr const char* kGiteaRepo = "twisla/roro9stack";
+
+inline bool versionNewer(const std::string& a, const std::string& b) { return versionOlder(b, a); }
+
+// "v0.10.0+debug": the Debug Build says so wherever the version shows (scripts/version.py).
+inline bool isDebugBuild(const std::string& version) {
+    static const std::string tail = "+debug";
+    return version.size() >= tail.size() && version.compare(version.size() - tail.size(), tail.size(), tail) == 0;
+}
+
+// Is `release` a newer one than what runs?
+inline bool isNewer(const Release& release, const std::string& running) {
+    return release.usable() && versionNewer(release.tag, running);
+}
+
+// Should the background check say so (Q166, Q168)? Not for a version that failed on this device
+// before (it rolled back), and not twice for the same one.
+inline bool shouldAnnounce(const Release& latest, const std::string& running, const std::string& failed, const std::string& announced) {
+    return isNewer(latest, running) && latest.tag != failed && latest.tag != announced;
+}
+
+// Is `url` a download this device takes from the project's server, for this repository? Whatever
+// the API says, the device only fetches from where it asked (a redirected or rewritten answer
+// can't send it elsewhere).
+bool trustedAssetUrl(const std::string& url, const std::string& host = kGiteaHost, const std::string& repo = kGiteaRepo);
+
+}  // namespace roro::release
@@ -10,7 +10,10 @@ bool PowerPolicy::activity(uint32_t nowMs) {
 }

 ScreenState PowerPolicy::update(uint32_t nowMs) {
-    uint32_t idle = nowMs - lastActivityMs_;
+    // Activity stamped from a clock read after this pass's nowMs (the Debug Console's `key`) is in
+    // the future, not 49 days ago: unsigned, the screen went off for a tick and ate the next key.
+    int32_t since = static_cast<int32_t>(nowMs - lastActivityMs_);
+    uint32_t idle = since < 0 ? 0 : static_cast<uint32_t>(since);
    state_ = idle >= offMs_ ? ScreenState::Off : idle >= dimMs_ ? ScreenState::Dimmed : ScreenState::On;
    if (notifying_) {
        if (static_cast<int32_t>(nowMs - notifyUntilMs_) >= 0)
@@ -39,6 +39,8 @@ const Definition kDefinitions[] = {
    {"dns_always", Kind::Bool, 0, nullptr, 0, 1},
    {"ntp1", Kind::String, 0, "pool.ntp.org", 1, 63},
    {"ntp2", Kind::String, 0, "time.cloudflare.com", 0, 63},
+    {"gnss_quiet", Kind::Bool, 0, nullptr, 0, 1},  // off: GNSS stays on, as decided in M2 (Q58)
+    {"check_updates", Kind::Bool, 1, nullptr, 0, 1},  // on: it only looks, and says so (R1, Q165)
 };
 static_assert(sizeof(kDefinitions) / sizeof(kDefinitions[0]) == static_cast<size_t>(Setting::Count),
              "every Setting needs a definition");
@@ -29,6 +29,8 @@ enum class Setting : uint8_t {
    DnsAlways,        // bool: use them on Automatic (DHCP) networks too, instead of DHCP's
    Ntp1,             // string: the first NTP server, a host name or an IPv4 address (S1, Q110)
    Ntp2,             // string: the second, or empty
+    GnssQuietForLora, // bool: put the GNSS receiver in standby while the LoRa radio listens (issue #20)
+    CheckUpdates,     // bool: look for a newer release on Gitea once a day (R1, Q165)
    Count
 };

@@ -24,7 +24,7 @@ void StorageMonitor::update(bool present, uint64_t totalBytes, uint64_t usedByte

    if (next.present && next.level >= 80 && !warned_) {
        warned_ = true;
-        bus_.publish(Event::withText(EventType::Notification, "SD card over 80% full",
+        bus_.publish(Event::withText(EventType::Notification, "SD card over 80% full: see Storage",
                                     static_cast<int32_t>(NotificationLevel::Warning)));
    }
 }
@@ -0,0 +1,72 @@
+#include "task_stats.h"
+
+#include <algorithm>
+#include <cctype>
+#include <cstring>
+
+namespace roro {
+
+std::vector<TaskRow> taskRows(const std::vector<TaskSample>& before, uint32_t totalBefore,
+                              const std::vector<TaskSample>& now, uint32_t totalNow) {
+    uint32_t elapsed = totalNow - totalBefore;  // unsigned: right across one wrap
+    std::vector<TaskRow> rows;
+    rows.reserve(now.size());
+    for (const TaskSample& t : now) {
+        uint32_t ran = t.runtime;  // a task that wasn't there before ran all of it since
+        for (const TaskSample& b : before)
+            if (b.id == t.id) {
+                ran = t.runtime - b.runtime;
+                break;
+            }
+        TaskRow r;
+        r.name = t.name;
+        r.core = t.core;
+        r.state = t.state;
+        r.priority = t.priority;
+        r.stackFree = t.stackFree;
+        r.permille = elapsed ? static_cast<uint16_t>(std::min<uint64_t>(1000, static_cast<uint64_t>(ran) * 1000 / elapsed)) : 0;
+        r.lowStack = t.stackFree < kLowStackBytes;
+        r.idle = std::strncmp(t.name, "IDLE", 4) == 0;
+        rows.push_back(r);
+    }
+    // The task that took the sample is running, and FreeRTOS counts a task's time when it's
+    // switched out: with its core to itself it never was, and its counter hardly moved. Give it
+    // what's left of its core once the idle task and the other tasks pinned there are counted.
+    for (TaskRow& r : rows) {
+        if (r.state != 0 || r.idle || r.core < 0) continue;  // 0: eRunning
+        int others = 0;
+        bool idleSeen = false;
+        for (const TaskRow& o : rows) {
+            if (&o == &r || o.core != r.core) continue;
+            others += o.permille;
+            idleSeen |= o.idle;
+        }
+        if (idleSeen && elapsed && 1000 - others > r.permille) r.permille = static_cast<uint16_t>(std::max(0, 1000 - others));
+    }
+    return rows;
+}
+
+int coreLoad(const std::vector<TaskRow>& rows, int core) {
+    for (const TaskRow& r : rows)
+        if (r.idle && r.core == core) return 100 - (r.permille + 5) / 10;
+    return -1;
+}
+
+void sortTasks(std::vector<TaskRow>& rows, TaskSort by) {
+    auto lower = [](const std::string& s) {
+        std::string l = s;
+        for (char& c : l) c = static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+        return l;
+    };
+    std::stable_sort(rows.begin(), rows.end(), [&](const TaskRow& a, const TaskRow& b) {
+        switch (by) {
+            case TaskSort::Share:
+                if (a.idle != b.idle) return !a.idle;  // idle tasks last
+                return a.permille > b.permille;
+            case TaskSort::Stack: return a.stackFree < b.stackFree;
+            default: return lower(a.name) < lower(b.name);
+        }
+    });
+}
+
+}  // namespace roro
@@ -0,0 +1,65 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <cstdio>
+#include <string>
+#include <vector>
+
+namespace roro {
+
+// One task as FreeRTOS reports it at one moment.
+struct TaskSample {
+    uint32_t id = 0;       // unique per task: a new task with an old name has another
+    char name[17] = {};
+    uint32_t runtime = 0;  // microseconds on a CPU since it started; 32 bits, so it wraps every 71 minutes
+    uint16_t stackFree = 0;  // the least it ever had left, bytes
+    int8_t core = -1;        // -1: not pinned
+    uint8_t state = 0;       // eTaskState
+    uint8_t priority = 0;
+};
+
+// What the System App and `tasks` show for a task (S1, Q119, Q122).
+struct TaskRow {
+    std::string name;
+    int core = -1;
+    uint8_t state = 0, priority = 0;
+    uint16_t stackFree = 0;
+    uint16_t permille = 0;  // share of one core over the interval, in tenths of a percent
+    bool lowStack = false;
+    bool idle = false;      // a core's idle task: what's left over
+};
+
+constexpr uint16_t kLowStackBytes = 512;
+
+// Shares from two samples: each task's run time between them over the time that passed. The
+// 32-bit counters may have wrapped once in between. The task that took the samples (the one
+// running) gets what's left of its core: see the .cpp.
+std::vector<TaskRow> taskRows(const std::vector<TaskSample>& before, uint32_t totalBefore,
+                              const std::vector<TaskSample>& now, uint32_t totalNow);
+
+// A core's load in percent: what its idle task didn't use. -1 without that task in the rows.
+int coreLoad(const std::vector<TaskRow>& rows, int core);
+
+enum class TaskSort : uint8_t { Share, Stack, Name };
+void sortTasks(std::vector<TaskRow>& rows, TaskSort by);
+
+// The last N samples, oldest first (Q120).
+template <typename T, size_t N>
+class History {
+   public:
+    void push(T value) {
+        values_[(first_ + size_) % N] = value;
+        if (size_ < N) size_++;
+        else first_ = (first_ + 1) % N;
+    }
+    size_t size() const { return size_; }
+    T at(size_t i) const { return values_[(first_ + i) % N]; }  // 0: the oldest kept
+    void clear() { first_ = size_ = 0; }
+
+   private:
+    T values_[N] = {};
+    size_t first_ = 0, size_ = 0;
+};
+
+}  // namespace roro
@@ -46,3 +46,14 @@ build_flags =
 platform = native
 lib_ldf_mode = deep+
 build_flags = -std=gnu++17
+
+; The same tests, built to count which lines of lib/ they run (scripts/coverage.sh).
+[env:native-coverage]
+extends = env:native
+build_flags =
+    ${env:native.build_flags}
+    --coverage
+    -O0
+extra_scripts =
+    ${env.extra_scripts}
+    pre:scripts/coverage_link.py
@@ -1,8 +1,10 @@
 # Shared helper: run a command inside the roro9stack build container.
+# With RORO_NO_DOCKER set, the caller is in such a container already (a CI job): the command runs
+# right here, in the checkout.
 IMAGE=roro9stack-build
 ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"

-docker build -q -t "$IMAGE" "$ROOT/docker" >/dev/null
+[ -n "${RORO_NO_DOCKER:-}" ] || docker build -q -t "$IMAGE" "$ROOT/docker" >/dev/null

 # The Debug Console token (ADR 0004): made once, kept with the OTA key, never committed.
 DEBUG_TOKEN_FILE="$HOME/.config/roro9stack/debug-token"
@@ -12,6 +14,10 @@ if [ ! -s "$DEBUG_TOKEN_FILE" ]; then
 fi

 run_in_container() {
+    if [ -n "${RORO_NO_DOCKER:-}" ]; then
+        (cd "$ROOT" && RORO_DEBUG_TOKEN="$(cat "$DEBUG_TOKEN_FILE")" "$@")
+        return
+    fi
    docker run --rm \
        -u "$(id -u):$(id -g)" -e HOME=/tmp \
        -e RORO_DEBUG_TOKEN="$(cat "$DEBUG_TOKEN_FILE")" \
@@ -1,7 +1,14 @@
 #!/usr/bin/env bash
 # Local CI: run host unit tests, then build the firmware.
+# Usage: scripts/ci.sh [tests|builds]   one half only; both by default
 set -euo pipefail
 source "$(dirname "$0")/_docker.sh"
 DOCKER_EXTRA=()

-run_in_container bash -c 'git config --global --add safe.directory /work && pio test -e native && pio run -e cardputer-adv -e cardputer-adv-debug'
+case "${1:-all}" in
+    tests) STEPS='pio test -e native' ;;
+    builds) STEPS='pio run -e cardputer-adv -e cardputer-adv-debug' ;;
+    all) STEPS='pio test -e native && pio run -e cardputer-adv -e cardputer-adv-debug' ;;
+    *) echo "Usage: scripts/ci.sh [tests|builds]" >&2; exit 1 ;;
+esac
+run_in_container bash -c 'git config --global --add safe.directory "$PWD" && '"$STEPS"
@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+# Runs the host tests and says how much of lib/ they run: they're built with coverage counters.
+# Usage: scripts/coverage.sh [out folder, default .pio/coverage]
+# Out: summary.json (gcovr), coverage.svg (the README's badge), index.html (line by line).
+# What it measures: the lines of lib/ that compile on a PC. Not lib/SD (the card's driver) and not
+# src/ (the Apps, the Services, everything that needs the device): those have no host tests.
+set -euo pipefail
+source "$(dirname "$0")/_docker.sh"
+DOCKER_EXTRA=()
+OUT="${1:-.pio/coverage}"
+
+run_in_container bash -c '
+    set -eo pipefail  # a failing test fails this script, tail or not
+    git config --global --add safe.directory "$PWD"
+    rm -rf .pio/build/native-coverage "'"$OUT"'"
+    mkdir -p "'"$OUT"'"
+    pio test -e native-coverage | tail -1
+    gcovr -r . --filter "lib/" --object-directory .pio/build/native-coverage \
+        --json-summary "'"$OUT"'/summary.json" --html-details "'"$OUT"'/index.html" --print-summary | tail -4
+    python3 scripts/coverage_badge.py "'"$OUT"'/summary.json" "'"$OUT"'/coverage.svg"
+'
@@ -0,0 +1,46 @@
+#!/usr/bin/env python3
+"""Draws the README's coverage badge from gcovr's summary.
+
+Usage: scripts/coverage_badge.py <summary.json> <out.svg>
+       scripts/coverage_badge.py --plain <label> <value> <out.svg>   any other badge, in blue
+Also prints one line, and appends a short table to $GITHUB_STEP_SUMMARY when CI sets it.
+"""
+import json
+import os
+import sys
+
+
+def badge(label, value, color, title):
+    left, right = 6 * len(label) + 12, 7 * len(value) + 12
+    return f'''<svg xmlns="http://www.w3.org/2000/svg" width="{left + right}" height="20" role="img" aria-label="{label}: {value}">
+<title>{title}</title>
+<linearGradient id="s" x2="0" y2="100%"><stop offset="0" stop-color="#bbb" stop-opacity=".1"/><stop offset="1" stop-opacity=".1"/></linearGradient>
+<clipPath id="r"><rect width="{left + right}" height="20" rx="3" fill="#fff"/></clipPath>
+<g clip-path="url(#r)"><rect width="{left}" height="20" fill="#555"/><rect x="{left}" width="{right}" height="20" fill="{color}"/><rect width="{left + right}" height="20" fill="url(#s)"/></g>
+<g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,DejaVu Sans,sans-serif" font-size="11">
+<text x="{left / 2}" y="14">{label}</text><text x="{left + right / 2}" y="14">{value}</text></g></svg>
+'''
+
+
+def main():
+    if sys.argv[1] == "--plain":  # any other badge: --plain <label> <value> <out.svg>
+        label, value, out = sys.argv[2:5]
+        open(out, "w").write(badge(label, value, "#007ec6", f"{label}: {value}"))
+        return
+    summary = json.load(open(sys.argv[1]))
+    lines, branches = summary["line_percent"], summary["branch_percent"]
+    label, value = "lib coverage", f"{lines:.0f}%"
+    color = "#4c1" if lines >= 90 else "#a4a61d" if lines >= 75 else "#dfb317" if lines >= 60 else "#e05d44"
+    svg = badge(label, value, color, f"{label}: {value} of the lines of lib/ are run by the host tests")
+    open(sys.argv[2], "w").write(svg)
+    print(f"coverage of lib/: {lines:.1f}% of {summary['line_total']} lines, {branches:.1f}% of branches, {len(summary['files'])} files")
+    step = os.environ.get("GITHUB_STEP_SUMMARY")
+    if step:
+        worst = sorted((f["line_percent"], f["filename"]) for f in summary["files"] if f["line_total"] >= 10)[:5]
+        with open(step, "a") as out:
+            out.write(f"### Coverage of `lib/` by the host tests\n\n**{lines:.1f}%** of {summary['line_total']} lines, {branches:.1f}% of branches.\n\n")
+            out.write("| Least covered | Lines |\n|---|---|\n" + "".join(f"| `{name}` | {pct:.0f}% |\n" for pct, name in worst))
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,4 @@
+# The coverage build must also link with --coverage (build_flags only reaches the compiler).
+Import("env")  # noqa: F821  (provided by PlatformIO)
+
+env.Append(LINKFLAGS=["--coverage"])  # noqa: F821
@@ -0,0 +1,49 @@
+#!/usr/bin/env python3
+"""Checks an Update File (.ota) the way the device does, on a PC: header, signature, image hash.
+
+Usage: scripts/ota_verify.py <file.ota> [public key, default keys/ota-public.pem]
+Exits 0 and prints the version if a device would accept the file.
+"""
+import hashlib
+import os
+import struct
+import subprocess
+import sys
+import tempfile
+
+HEADER_SIZE = 160
+SIGNED_BYTES = 80
+
+
+def main():
+    if len(sys.argv) < 2:
+        sys.exit(__doc__)
+    root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+    key = sys.argv[2] if len(sys.argv) > 2 else os.path.join(root, "keys", "ota-public.pem")
+    data = open(sys.argv[1], "rb").read()
+    if len(data) < HEADER_SIZE or data[:8] != b"RORO-OTA":
+        sys.exit("not an update file")
+    fmt, header_size, image_size = struct.unpack("<HHI", data[8:16])
+    if fmt != 1 or header_size != HEADER_SIZE:
+        sys.exit("unsupported update format")
+    image = data[HEADER_SIZE:]
+    if len(image) != image_size:
+        sys.exit(f"the header announces {image_size} bytes of image, the file has {len(image)}")
+    if hashlib.sha256(image).digest() != data[16:48]:
+        sys.exit("image corrupted (hash mismatch)")
+    version = data[48:80].split(b"\0")[0].decode()
+    (sig_len,) = struct.unpack("<H", data[80:82])
+    with tempfile.NamedTemporaryFile() as signed, tempfile.NamedTemporaryFile() as sig:
+        signed.write(data[:SIGNED_BYTES])
+        signed.flush()
+        sig.write(data[82:82 + sig_len])
+        sig.flush()
+        ok = subprocess.run(["openssl", "dgst", "-sha256", "-verify", key, "-signature", sig.name, signed.name],
+                            capture_output=True).returncode == 0
+    if not ok:
+        sys.exit("bad signature (wrong key)")
+    print(f"{sys.argv[1]}: {version}, {image_size} bytes, signature good")
+
+
+if __name__ == "__main__":
+    main()
@@ -224,10 +224,15 @@ def interactive(sock):
            sys.stdout.write(data.decode(errors="replace"))
            sys.stdout.flush()
        if sys.stdin in ready:
-            line = sys.stdin.readline()
-            if not line:
+            # Straight from the descriptor: readline() takes every waiting line into Python's own
+            # buffer and hands over one, and select() then sees nothing more to read. Piped input
+            # written while we were still connecting got stuck until the next line came.
+            data = os.read(sys.stdin.fileno(), 4096)
+            if not data:
                return
-            sock.sendall(line.encode())
+            sock.setblocking(True)
+            sock.sendall(data)
+            sock.setblocking(False)


 def main():
@@ -0,0 +1,62 @@
+#!/usr/bin/env bash
+# Builds what a release publishes, from a checkout of the repository at a tag (docs/milestones/R1.md).
+# Usage: scripts/release_build.sh <checkout> <out folder>
+#   <checkout>   a clone with its tags, at the commit to release: its own sources are built, with
+#                this copy's build image and signing tools, so an old tag can be released today.
+# The signing key is read from $RORO_OTA_KEY (a file), as scripts/make_ota.py does.
+# Out: roro9stack-<version>.ota (signed, checked), -factory.bin (USB), .elf.gz (to decode crashes),
+#      SHA256SUMS, and notes.md for the release's text.
+set -euo pipefail
+SRC="$(cd "$1" && pwd)"
+mkdir -p "$2"
+OUT="$(cd "$2" && pwd)"
+TOOLS="$(cd "$(dirname "$0")" && pwd)"
+
+VERSION="$(git -C "$SRC" describe --tags --always --dirty)"
+case "$VERSION" in
+    *-dirty) echo "release: $SRC has uncommitted changes ($VERSION)" >&2; exit 1 ;;
+esac
+git -C "$SRC" describe --tags --exact-match >/dev/null 2>&1 || { echo "release: $VERSION is not a tag" >&2; exit 1; }
+
+source "$TOOLS/_docker.sh"
+ROOT="$SRC"  # _docker.sh mounts $ROOT as /work: the checkout to build, not necessarily this copy
+DOCKER_EXTRA=()
+# A tag from before the framework was rebuilt with our settings (ADR 0006) can't link against a
+# rebuilt one left in the toolchain cache: it gets the framework's libraries as they come.
+if ! grep -q custom_sdkconfig "$SRC/platformio.ini"; then
+    run_in_container bash -c 'rm -rf "${PLATFORMIO_CORE_DIR:-/pio}/packages/framework-arduinoespressif32-libs"'
+fi
+run_in_container bash -c 'git config --global --add safe.directory "$PWD" && pio run -e cardputer-adv'
+
+BUILD="$SRC/.pio/build/cardputer-adv"
+NAME="roro9stack-$VERSION"
+"$TOOLS/make_ota.py" "$BUILD/firmware.bin" "$VERSION" "$OUT/$NAME.ota"
+# A wrong key must stop the release here, not on a device: checked against the public key the
+# sources being built carry (the tags from before Firmware Updates have none: today's, then).
+PUBLIC="$SRC/keys/ota-public.pem"
+[ -e "$PUBLIC" ] || PUBLIC="$TOOLS/../keys/ota-public.pem"
+"$TOOLS/ota_verify.py" "$OUT/$NAME.ota" "$PUBLIC"
+cp "$BUILD/firmware.factory.bin" "$OUT/$NAME-factory.bin"
+gzip -9 -c "$BUILD/firmware.elf" > "$OUT/$NAME.elf.gz"
+(cd "$OUT" && sha256sum "$NAME.ota" "$NAME-factory.bin" "$NAME.elf.gz" > SHA256SUMS)
+
+# The release's text: what the tag says, then what went in since the tag before.
+PREVIOUS="$(git -C "$SRC" describe --tags --abbrev=0 "$VERSION^" 2>/dev/null || true)"
+{
+    git -C "$SRC" tag -l --format='%(contents)' "$VERSION" | sed -e '/^-----BEGIN PGP/,$d'
+    echo
+    echo "## Files"
+    echo
+    echo "- \`$NAME.ota\`: the signed Update File. Copy it to \`/updates\` on the SD card and install it from Settings > Firmware or the Storage App, or push it over Wi-Fi with \`scripts/ota_push.py\`."
+    echo "- \`$NAME-factory.bin\`: the whole flash image, for a first install over USB at offset 0."
+    echo "- \`$NAME.elf.gz\`: the symbols, to decode a crash report from this build."
+    echo "- \`SHA256SUMS\`: checksums of the three."
+    if [ -n "$PREVIOUS" ]; then
+        echo
+        echo "## Changes since $PREVIOUS"
+        echo
+        git -C "$SRC" log --no-merges --format='- %s' "$PREVIOUS..$VERSION"
+    fi
+} > "$OUT/notes.md"
+echo "$VERSION" > "$OUT/version"
+ls -l "$OUT"
@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""Creates or completes a Gitea release from what scripts/release_build.sh made.
+
+Usage: scripts/release_publish.py <folder>
+Environment: GITEA_API (https://host/api/v1), GITEA_REPO (owner/name), GITEA_TOKEN.
+Run again for the same version, it replaces the files and the text instead of failing.
+"""
+import json
+import os
+import sys
+import urllib.error
+import urllib.parse
+import urllib.request
+
+API = os.environ.get("GITEA_API", "").rstrip("/")
+REPO = os.environ.get("GITEA_REPO", "")
+TOKEN = os.environ.get("GITEA_TOKEN", "")
+
+
+def call(method, path, body=None, raw=None, content_type="application/json"):
+    data = raw if raw is not None else (json.dumps(body).encode() if body is not None else None)
+    request = urllib.request.Request(f"{API}/repos/{REPO}{path}", data=data, method=method)
+    request.add_header("Authorization", f"token {TOKEN}")
+    if data is not None:
+        request.add_header("Content-Type", content_type)
+    try:
+        with urllib.request.urlopen(request, timeout=300) as response:
+            text = response.read()
+            return response.status, json.loads(text) if text else None
+    except urllib.error.HTTPError as e:
+        return e.code, e.read().decode(errors="replace")[:300]
+
+
+def main():
+    if len(sys.argv) != 2 or not (API and REPO and TOKEN):
+        sys.exit(__doc__)
+    folder = sys.argv[1]
+    version = open(os.path.join(folder, "version")).read().strip()
+    notes = open(os.path.join(folder, "notes.md")).read()
+    files = sorted(f for f in os.listdir(folder) if f not in ("version", "notes.md"))
+
+    status, release = call("GET", f"/releases/tags/{urllib.parse.quote(version)}")
+    fields = {"tag_name": version, "name": f"roro9stack {version}", "body": notes, "draft": False, "prerelease": False}
+    if status == 200:
+        status, release = call("PATCH", f"/releases/{release['id']}", fields)
+    else:
+        status, release = call("POST", "/releases", fields)
+    if status not in (200, 201):
+        sys.exit(f"release: Gitea answered {status}: {release}")
+
+    for asset in release.get("assets") or []:  # a second run replaces what the first uploaded
+        if asset["name"] in files:
+            call("DELETE", f"/releases/{release['id']}/assets/{asset['id']}")
+    for name in files:
+        with open(os.path.join(folder, name), "rb") as f:
+            status, answer = call("POST", f"/releases/{release['id']}/assets?name={urllib.parse.quote(name)}", raw=f.read(),
+                                  content_type="application/octet-stream")
+        if status != 201:
+            sys.exit(f"release: uploading {name}: Gitea answered {status}: {answer}")
+        print(f"uploaded {name} ({answer['size']} bytes)")
+    print(f"published {release['html_url']}")
+
+
+if __name__ == "__main__":
+    main()
@@ -0,0 +1,470 @@
+#include "file_viewer.h"
+
+#include <Arduino.h>
+#include <SD.h>
+
+#include <algorithm>
+#include <atomic>
+#include <cstdio>
+#include <ctime>
+
+#include "cleanup_plan.h"
+#include "file_list.h"
+#include "file_names.h"
+#include "file_views.h"
+#include "meshtastic_presets.h"
+#include "packet_view.h"
+#include "platform/ota_device.h"
+#include "ui/fonts.h"
+#include "ui/widgets.h"
+#include "update_parser.h"
+#include "version.h"
+
+namespace roro {
+
+namespace {
+constexpr uint32_t kSliceMs = 150;      // like the Storage App's operations: the Logs get their turn
+constexpr size_t kPiece = 1024;
+constexpr size_t kMaxPackets = 1000;    // their places in the file, 4 KB
+constexpr size_t kMaxPacketBytes = 271;  // LoRaTap and the longest LoRa packet
+
+// Checks an Update File as an install would, writing nothing.
+struct NoSink : UpdateSink {
+    bool begin(size_t) override { return true; }
+    bool write(const uint8_t*, size_t) override { return true; }
+    bool finish() override { return true; }
+    void abort() override {}
+};
+
+std::string clockTime(uint32_t utcSeconds) {
+    time_t t = static_cast<time_t>(utcSeconds);
+    struct tm local;
+    localtime_r(&t, &local);
+    char s[12];
+    std::snprintf(s, sizeof s, "%02d:%02d:%02d", local.tm_hour, local.tm_min, local.tm_sec);
+    return s;
+}
+}  // namespace
+
+struct FileViewer::Scan {
+    std::atomic<bool> done{false}, stop{false};
+    std::atomic<int> percent{0};
+    Mode what = Mode::Gpx;
+    std::string path;
+    // Touched by the storage task until `done`, by the viewer after.
+    fs::File file;
+    bool opened = false;
+    uint32_t at = 0, size = 0;
+    std::string error;
+    files::GpxSummary gpx;
+    files::PcapHeader pcap;
+    std::vector<uint32_t> packets;  // where each record starts
+    bool morePackets = false;
+    std::unique_ptr<EcdsaVerifier> verifier;
+    NoSink sink;
+    std::unique_ptr<UpdateParser> parser;
+    std::string version;
+    bool genuine = false, older = false;
+
+    bool slice();  // true when there's nothing more to read
+    static void run(StorageService* storage, std::shared_ptr<Scan> self) {
+        bool over = self->stop || self->slice();
+        if (over) {
+            if (self->file) self->file.close();
+            self->parser.reset();
+            self->verifier.reset();
+            self->done = true;
+        } else {
+            storage->runJob([storage, self]() { run(storage, self); });
+        }
+    }
+};
+
+bool FileViewer::Scan::slice() {
+    uint32_t t0 = millis();
+    if (!opened) {
+        opened = true;
+        file = SD.open(path.c_str(), FILE_READ);
+        if (!file) {
+            error = "The card refused to open it";
+            return true;
+        }
+        size = static_cast<uint32_t>(file.size());
+        if (what == Mode::Ota) {
+            verifier.reset(new EcdsaVerifier());
+            parser.reset(new UpdateParser(*verifier, sink, EspOtaSink().capacity(), versionString()));
+        }
+    }
+    std::unique_ptr<uint8_t[]> piece(new uint8_t[kPiece]);
+    while (millis() - t0 < kSliceMs) {
+        if (stop) return true;
+        if (what == Mode::Pcap) {
+            if (at == 0) {
+                int n = file.read(piece.get(), files::kPcapHeaderSize);
+                pcap = files::parsePcapHeader(piece.get(), n < 0 ? 0 : n);
+                if (!pcap.ok) {
+                    error = "Not a pcap file this viewer reads";
+                    return true;
+                }
+                at = files::kPcapHeaderSize;
+            }
+            files::PcapRecord r;
+            if (!file.seek(at)) return true;
+            int n = file.read(piece.get(), files::kPcapRecordSize);
+            if (n < 0 || !files::parsePcapRecord(piece.get(), n, r) || at + files::kPcapRecordSize + r.length > size) return true;
+            if (packets.size() >= kMaxPackets) {
+                morePackets = true;
+                return true;
+            }
+            packets.push_back(at);
+            at += files::kPcapRecordSize + r.length;
+            continue;
+        }
+        int n = file.read(piece.get(), kPiece);
+        if (n <= 0) break;
+        at += n;
+        percent = size ? static_cast<int>(static_cast<uint64_t>(at) * 100 / size) : 100;
+        if (what == Mode::Gpx) {
+            gpx.feed(reinterpret_cast<const char*>(piece.get()), n);
+        } else {
+            parser->feed(piece.get(), n);
+            if (parser->state() == UpdateParser::State::Failed) break;
+        }
+    }
+    if (at < size && !(parser && parser->state() == UpdateParser::State::Failed) && millis() - t0 >= kSliceMs) return false;
+    if (parser) {
+        genuine = parser->end();
+        version = parser->version();
+        older = parser->isDowngrade();
+        error = parser->error();
+    }
+    return true;
+}
+
+size_t FileViewer::readAt(uint32_t offset, uint8_t* into, size_t len) {
+    size_t got = 0;
+    auto file = file_;
+    std::string path = path_;
+    storage_.runAndWait([&, file, path]() {
+        if (!*file) *file = SD.open(path.c_str(), FILE_READ);
+        if (!*file || !file->seek(offset)) return;
+        int n = file->read(into, len);
+        got = n < 0 ? 0 : n;
+    });
+    return got;
+}
+
+void FileViewer::open(const std::string& path, uint32_t size) {
+    close();
+    path_ = path;
+    size_ = size;
+    file_ = std::make_shared<fs::File>();
+    std::string name = files::baseName(path);
+    files::FileKind kind = files::kindOf(name);
+    if (kind == files::FileKind::Unknown) {  // what do its first bytes look like?
+        uint8_t head[256];
+        size_t n = readAt(0, head, sizeof head);
+        kind = files::looksLikeText(head, n) ? files::FileKind::Text : files::FileKind::Unknown;
+    }
+    switch (kind) {
+        case files::FileKind::Text: base_ = Mode::Text; break;
+        case files::FileKind::Gpx: base_ = Mode::Gpx; break;
+        case files::FileKind::Pcap: base_ = Mode::Pcap; break;
+        case files::FileKind::Ota: base_ = Mode::Ota; break;
+        default: base_ = Mode::Hex; break;
+    }
+    pager_.reset(new files::TextPager([this](uint32_t offset, uint8_t* into, size_t len) { return readAt(offset, into, len); }, size_,
+                                      kCols, kRows));
+    if (files::opensAtEnd(name)) pager_->toEnd();
+    hexTop_ = 0;
+    show(base_);
+    if (base_ == Mode::Gpx || base_ == Mode::Pcap || base_ == Mode::Ota) startScan(base_);
+}
+
+void FileViewer::startScan(Mode mode) {
+    scan_ = std::make_shared<Scan>();
+    scan_->what = mode;
+    scan_->path = path_;
+    scanShown_ = false;
+    shownPercent_ = -1;
+    auto scan = scan_;
+    StorageService* storage = &storage_;
+    storage_.runJob([storage, scan]() { Scan::run(storage, scan); });
+}
+
+void FileViewer::close() {
+    if (scan_) scan_->stop = true;  // its job ends at the next piece and frees itself
+    scan_.reset();
+    if (file_) {
+        auto file = file_;
+        storage_.runJob([file]() {
+            if (*file) file->close();
+        });
+    }
+    file_.reset();
+    pager_.reset();
+    confirm_.reset();
+    message_.clear();
+    std::vector<std::string>().swap(shown_);
+    std::vector<std::string>().swap(details_);
+    packets_.setCount(0);
+    rowsFrom_ = -1;
+}
+
+void FileViewer::show(Mode mode) {
+    mode_ = mode;
+    stale_ = true;
+    rowsFrom_ = -1;
+}
+
+void FileViewer::say(const std::string& text) {
+    message_ = text;
+    messageMs_ = millis();
+}
+
+std::string FileViewer::title() const { return files::fitName(files::baseName(path_), 24); }
+
+void FileViewer::scroll(int lines) {
+    if (mode_ == Mode::Text && pager_) {
+        if (lines > 0) pager_->down(lines);
+        else pager_->up(-lines);
+    } else if (mode_ == Mode::Hex) {
+        uint32_t rows = (size_ + 7) / 8, last = rows > static_cast<uint32_t>(kRows) ? rows - kRows : 0;
+        int64_t to = static_cast<int64_t>(hexTop_) + lines;
+        hexTop_ = static_cast<uint32_t>(std::clamp<int64_t>(to, 0, last));
+    }
+    stale_ = true;
+}
+
+void FileViewer::openPacket(int index) {
+    if (!scan_ || !scan_->done || index < 0 || index >= static_cast<int>(scan_->packets.size())) return;
+    uint8_t buf[files::kPcapRecordSize + kMaxPacketBytes];
+    size_t n = readAt(scan_->packets[index], buf, sizeof buf);
+    files::PcapRecord r;
+    if (!files::parsePcapRecord(buf, n, r)) return;
+    const uint8_t* body = buf + files::kPcapRecordSize;
+    size_t have = std::min<size_t>(r.length, n - files::kPcapRecordSize);
+    details_.clear();
+    char line[64];
+    lora::RxInfo rx;
+    bool tap = scan_->pcap.linkType == files::kLinkLoraTap && files::parseLoraTap(body, have, rx);
+    size_t skip = tap ? lora::kLoraTapSize : 0;
+    std::snprintf(line, sizeof line, "%s, %u bytes", clockTime(r.seconds).c_str(), static_cast<unsigned>(r.length - skip));
+    details_.push_back(line);
+    if (tap) {
+        std::snprintf(line, sizeof line, "%.0f dBm, SNR %.1f dB, noise %.0f", rx.rssi, rx.snr, rx.noiseFloor);
+        details_.push_back(line);
+        std::snprintf(line, sizeof line, "%.4f MHz, SF%u, %.0f kHz", rx.frequencyHz / 1e6, rx.spreadingFactor, rx.bandwidthKHz);
+        details_.push_back(line);
+        if (rx.syncWord == meshtastic::kSyncWord)
+            for (auto& l : lora::headerLines(body + skip, have - skip)) details_.push_back(l);
+    }
+    for (auto& l : lora::hexDump(body + skip, have - skip)) details_.push_back(l);
+    if (have < r.length) details_.push_back("(the first bytes only)");
+    detailsTop_ = 0;
+    mode_ = Mode::Packet;
+}
+
+bool FileViewer::onKey(const KeyEvent& e) {
+    if (confirm_) {
+        confirm_->onKey(e);
+        if (confirm_->result() == 1) update_.installFromSd(path_);
+        if (confirm_->result() != DialogModel::kPending) confirm_.reset();
+        return true;
+    }
+    if (mode_ == Mode::Packet) {
+        int last = std::max(0, static_cast<int>(details_.size()) - (kRows + 1));
+        if (e.key == Key::Up) detailsTop_ = std::max(0, detailsTop_ - 1);
+        else if (e.key == Key::Down) detailsTop_ = std::min(last, detailsTop_ + 1);
+        else if (e.key == Key::Back || e.key == Key::Select) mode_ = Mode::Pcap;
+        return true;
+    }
+    if (e.key == Key::Back) return false;
+    if (e.key == Key::Tab) {
+        // The file's own view, or what it's made of: text for a Track, bytes for the others.
+        if (mode_ != base_) show(base_);
+        else show(base_ == Mode::Hex || base_ == Mode::Gpx ? Mode::Text : Mode::Hex);
+        return true;
+    }
+    uint32_t ch = e.key == Key::Char ? e.ch : 0;
+    switch (mode_) {
+        case Mode::Text:
+        case Mode::Hex:
+            if (e.key == Key::Up) scroll(-1);
+            else if (e.key == Key::Down) scroll(1);
+            else if (e.key == Key::Left) scroll(-(kRows - 1));
+            else if (e.key == Key::Right) scroll(kRows - 1);
+            else if (ch == 't' || ch == 'T') {
+                if (pager_) pager_->toStart();
+                hexTop_ = 0;
+                stale_ = true;
+            } else if (ch == 'b' || ch == 'B') {
+                if (mode_ == Mode::Text && pager_) pager_->toEnd();
+                else scroll(INT32_MAX / 2);
+                stale_ = true;
+            }
+            break;
+        case Mode::Pcap:
+            if (e.key == Key::Up) packets_.up();
+            else if (e.key == Key::Down) packets_.down();
+            else if (e.key == Key::Left) packets_.pageUp();
+            else if (e.key == Key::Right) packets_.pageDown();
+            else if (e.key == Key::Select) openPacket(packets_.selected());
+            break;
+        case Mode::Ota:
+            if (e.key == Key::Select && scan_ && scan_->done && scan_->genuine) confirm_.reset(new DialogModel({"Cancel", "Install"}));
+            break;
+        default: break;
+    }
+    return true;
+}
+
+bool FileViewer::update(uint32_t) {
+    if (!message_.empty() && millis() - messageMs_ >= 4000) {
+        message_.clear();
+        return true;
+    }
+    if (!scan_) return false;
+    if (scan_->done && !scanShown_) {
+        scanShown_ = true;
+        if (scan_->what == Mode::Pcap) packets_.setCount(static_cast<int>(scan_->packets.size()));
+        return true;
+    }
+    int percent = scan_->percent;
+    if (!scan_->done && percent != shownPercent_) {
+        shownPercent_ = percent;
+        return true;
+    }
+    return false;
+}
+
+void FileViewer::refresh() {
+    if (mode_ == Mode::Text && stale_ && pager_) {
+        shown_ = pager_->lines();
+        stale_ = false;
+    } else if (mode_ == Mode::Hex && stale_) {
+        uint8_t buf[kRows * 8];
+        size_t n = readAt(hexTop_ * 8, buf, sizeof buf);
+        shown_.clear();
+        for (size_t at = 0; at < n; at += 8) shown_.push_back(files::hexRow(hexTop_ * 8 + at, buf + at, std::min<size_t>(8, n - at)));
+        stale_ = false;
+    } else if (mode_ == Mode::Pcap && scan_ && scan_->done && rowsFrom_ != packets_.firstVisible()) {
+        // The rows on screen, read from the card once each time the list moves.
+        rowsFrom_ = packets_.firstVisible();
+        shown_.clear();
+        bool tap = scan_->pcap.linkType == files::kLinkLoraTap;
+        for (int i = rowsFrom_; i < rowsFrom_ + kRows && i < static_cast<int>(scan_->packets.size()); i++) {
+            uint8_t buf[files::kPcapRecordSize + kMaxPacketBytes];
+            size_t n = readAt(scan_->packets[i], buf, sizeof buf);
+            files::PcapRecord r;
+            lora::RxInfo rx;
+            if (!files::parsePcapRecord(buf, n, r)) {
+                shown_.push_back("(unreadable)");
+                continue;
+            }
+            const uint8_t* body = buf + files::kPcapRecordSize;
+            size_t have = std::min<size_t>(r.length, n - files::kPcapRecordSize);
+            if (tap && files::parseLoraTap(body, have, rx)) {
+                shown_.push_back(lora::row({body + lora::kLoraTapSize, have - lora::kLoraTapSize, rx.rssi, rx.snr, true,
+                                            rx.syncWord == meshtastic::kSyncWord},
+                                           clockTime(r.seconds)));
+            } else {
+                shown_.push_back(clockTime(r.seconds) + "  " + std::to_string(r.length) + " bytes");
+            }
+        }
+    }
+}
+
+void FileViewer::draw(Canvas& c) {
+    const auto& area = theme::kContent;
+    refresh();
+    c.setTextDatum(top_left);
+    theme::Rect body{area.x, area.y + 10, area.w, kRows * theme::kLineHeight};
+    std::string right, keys = "Tab: hex";
+    bool scanning = scan_ && !scan_->done;
+
+    switch (mode_) {
+        case Mode::Text:
+        case Mode::Hex: {
+            c.setFont(&fonts::body);
+            c.setTextColor(size_ == 0 ? theme::kMuted : theme::kText);
+            if (size_ == 0) c.drawString("(empty)", 4, body.y + 1);
+            for (size_t i = 0; i < shown_.size(); i++) c.drawString(shown_[i].c_str(), 4, body.y + 1 + static_cast<int>(i) * theme::kLineHeight);
+            uint32_t at = mode_ == Mode::Text && pager_ ? pager_->top() : hexTop_ * 8;
+            if (size_ > 0) {  // where in the file the screen is
+                int barH = 12, barY = body.y + static_cast<int>(static_cast<uint64_t>(body.h - barH) * at / size_);
+                c.fillRect(area.w - 2, barY, 2, barH, theme::kMuted);
+            }
+            right = formatBytes(size_);
+            keys = std::string("Tab: ") + (mode_ != base_ ? "back" : mode_ == Mode::Text ? "hex" : "text") + "  t: top  b: end";
+            if (mode_ == Mode::Text) keys += "  e: edit";
+            break;
+        }
+        case Mode::Gpx: {
+            std::vector<std::string> lines;
+            if (scanning) lines.push_back("Reading the Track... " + std::to_string(scan_->percent.load()) + "%");
+            else if (scan_ && !scan_->error.empty()) lines.push_back(scan_->error);
+            else if (scan_) lines = scan_->gpx.lines();
+            widgets::textLines(c, lines, 0, body);
+            right = formatBytes(size_);
+            keys = "Tab: the file as text";
+            break;
+        }
+        case Mode::Pcap: {
+            c.setFont(&fonts::body);
+            c.setTextColor(theme::kMuted);
+            if (scanning) c.drawString("Reading the Capture...", 4, body.y + 1);
+            else if (scan_ && !scan_->error.empty()) c.drawString(scan_->error.c_str(), 4, body.y + 1);
+            else if (scan_ && scan_->packets.empty()) c.drawString("No packets in this Capture.", 4, body.y + 1);
+            else if (scan_) {
+                int from = rowsFrom_;
+                widgets::list(c, packets_, body, [&](int i) {
+                    size_t row = static_cast<size_t>(i - from);
+                    return row < shown_.size() ? shown_[row] : std::string();
+                });
+                right = std::to_string(scan_->packets.size()) + (scan_->morePackets ? "+ packets" : " packets");
+                keys = "Enter: the packet  Tab: hex";
+            }
+            break;
+        }
+        case Mode::Packet: widgets::textLines(c, details_, detailsTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 2}); return;
+        case Mode::Ota: {
+            std::vector<std::string> lines;
+            bool ok = scan_ && scan_->done && scan_->genuine;
+            if (scanning) {
+                lines.push_back("Checking it as an install would:");
+                lines.push_back("signature and contents, " + std::to_string(scan_->percent.load()) + "%");
+            } else if (scan_) {
+                if (!scan_->version.empty()) lines.push_back("Version " + scan_->version);
+                lines.push_back(std::string("Running ") + versionString());
+                if (ok) {
+                    lines.push_back("Signed with the project's key, intact.");
+                    if (scan_->older) lines.push_back("Older than what's running.");
+                } else {
+                    lines.push_back("Not installable:");
+                    lines.push_back(scan_->error.empty() ? "it ends too early" : scan_->error);
+                }
+            }
+            widgets::textLines(c, lines, 0, body);
+            right = formatBytes(size_);
+            keys = ok ? "Enter: install  Tab: hex" : "Tab: hex";
+            if (confirm_) {
+                widgets::dialog(c, "Install update?", "The device restarts into " + scan_->version + " once it's written.", *confirm_);
+                return;
+            }
+            break;
+        }
+    }
+
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.setTextDatum(top_left);
+    c.drawString(title().c_str(), 4, area.y + 1);
+    c.setTextDatum(top_right);
+    c.drawString(right.c_str(), area.w - 3, area.y + 1);
+    c.setTextDatum(top_left);
+    if (!message_.empty()) c.setTextColor(theme::kWarning);
+    c.drawString(message_.empty() ? keys.c_str() : message_.c_str(), 4, area.y + area.h - 9);
+}
+
+}  // namespace roro
@@ -0,0 +1,75 @@
+#pragma once
+
+#include <FS.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "dialog_model.h"
+#include "key_event.h"
+#include "list_model.h"
+#include "services/storage_service.h"
+#include "services/update_service.h"
+#include "text_pager.h"
+#include "ui/canvas.h"
+#include "ui/theme.h"
+
+namespace roro {
+
+// Looks inside a file for the Storage App (F1, Q134), by type: text read as it's scrolled, a hex
+// dump, a Capture's packets, a Track's summary, an Update File's version and whether it's
+// genuine. Tab switches to the text or the hex of the same file. Nothing here changes a file.
+class FileViewer {
+   public:
+    FileViewer(StorageService& storage, UpdateService& update) : storage_(storage), update_(update) {}
+
+    void open(const std::string& path, uint32_t size);
+    void close();
+    bool onKey(const KeyEvent& e);  // false: leave the viewer
+    bool update(uint32_t nowMs);    // true: draw again
+    void draw(Canvas& c);
+
+    // For `e` in the Storage App: is this a text small enough to edit (Q146)? And a line to say why not.
+    bool showingText() const { return mode_ == Mode::Text; }
+    const std::string& path() const { return path_; }
+    uint32_t size() const { return size_; }
+    void say(const std::string& text);
+
+   private:
+    enum class Mode { Text, Hex, Gpx, Pcap, Packet, Ota };
+    static constexpr int kRows = 8;
+    static constexpr int kCols = 38;
+    struct Scan;  // what a storage job reads through a whole file for: shared with that job
+
+    size_t readAt(uint32_t offset, uint8_t* into, size_t len);
+    void show(Mode mode);
+    void startScan(Mode mode);
+    void refresh();  // reads what the screen shows, when it has moved
+    void openPacket(int index);
+    void scroll(int lines);
+    std::string title() const;
+
+    StorageService& storage_;
+    UpdateService& update_;
+    std::string path_;
+    uint32_t size_ = 0;
+    Mode mode_ = Mode::Text, base_ = Mode::Text;
+    std::shared_ptr<fs::File> file_;  // opened and read on the storage task only
+    std::unique_ptr<files::TextPager> pager_;
+    uint32_t hexTop_ = 0;  // in rows of eight bytes
+    std::vector<std::string> shown_;  // the rows on screen
+    bool stale_ = true;
+    std::shared_ptr<Scan> scan_;
+    bool scanShown_ = false;
+    int shownPercent_ = -1;
+    ListModel packets_{kRows};
+    int rowsFrom_ = -1;
+    std::vector<std::string> details_;
+    int detailsTop_ = 0;
+    std::unique_ptr<DialogModel> confirm_;
+    std::string message_;
+    uint32_t messageMs_ = 0;
+};
+
+}  // namespace roro
@@ -2,7 +2,14 @@

 #include <SD.h>

+#include <algorithm>
+
+#include "cleanup_plan.h"
+
+#include "text_wrap.h"
+#include "ui/fonts.h"
 #include "ui/widgets.h"
+#include "update_check.h"
 #include "version.h"

 namespace roro {
@@ -17,6 +24,9 @@ bool endsWith(const std::string& s, const std::string& suffix) {

 void FirmwarePage::enter() {
    confirm_.reset();
+    ask_ = Ask::None;
+    view_ = View::Main;
+    message_.clear();
    {
        std::lock_guard<std::mutex> g(lock_);
        files_.clear();
@@ -40,7 +50,76 @@ std::vector<std::string> FirmwarePage::files() {
    return files_;
 }

+void FirmwarePage::say(const std::string& text) {
+    message_ = text;
+    messageMs_ = millis();
+}
+
+// The row for the latest release: what's known, in a few words.
+std::string FirmwarePage::latestText(bool& warn) const {
+    warn = false;
+    GiteaReleases& g = update_.gitea();
+    if (update_.giteaBusy() || g.status() == GiteaReleases::Status::Busy) return "checking...";
+    release::Release r;
+    if (g.status() == GiteaReleases::Status::Failed && !g.latest(r)) {
+        warn = true;
+        return "failed: Enter retries";
+    }
+    if (!g.latest(r)) return "Enter: check";
+    return r.tag + (release::isNewer(r, update_.runningVersion()) ? " (new)" : " (current)");
+}
+
+void FirmwarePage::openRelease(const release::Release& r) {
+    shown_ = r;
+    shownTop_ = 0;
+    view_ = View::Release;
+}
+
+// Can the release on the page be installed from here, and if not, why (in words for the screen)?
+bool FirmwarePage::installable(std::string& why) const {
+    std::string running = update_.runningVersion();
+    if (!shown_.usable()) why = "Nothing to install in it";
+    else if (!release::versionNewer(shown_.tag, running) && !versionOlder(shown_.tag, running)) why = "That's the version running";
+    else if (release::isDebugBuild(running)) why = "A Debug Build keeps its console: update it from your PC";
+    else if (wifi_.state() != WifiController::State::Connected) why = "Not connected to Wi-Fi";
+    else return true;
+    return false;
+}
+
 bool FirmwarePage::onKey(const KeyEvent& e) {
+    if (view_ != View::Main) {
+        if (confirm_) {
+            confirm_->onKey(e);
+            if (confirm_->result() == 1 && ask_ == Ask::Release) {
+                std::string why = update_.requestInstall(shown_.tag);
+                if (!why.empty()) say(why);
+            }
+            if (confirm_->result() != DialogModel::kPending) confirm_.reset();
+            return true;
+        }
+        if (view_ == View::Release) {
+            if (e.key == Key::Back) view_ = olderReleases_.empty() || older_.count() == 0 ? View::Main : View::Older;
+            else if (e.key == Key::Up) shownTop_ = std::max(0, shownTop_ - 1);
+            else if (e.key == Key::Down) shownTop_++;  // clamped when drawn
+            else if (e.key == Key::Char && (e.ch == 'c' || e.ch == 'C') && !update_.giteaBusy()) update_.requestCheck();
+            else if (e.key == Key::Select) {
+                std::string why;
+                if (!installable(why)) return say(why), true;
+                ask_ = Ask::Release;
+                confirm_.reset(new DialogModel({"Cancel", "Install"}));
+            }
+            return true;
+        }
+        // The older releases.
+        if (e.key == Key::Back) view_ = View::Main;
+        else if (e.key == Key::Up) older_.up();
+        else if (e.key == Key::Down) older_.down();
+        else if (e.key == Key::Char && (e.ch == 'c' || e.ch == 'C') && !update_.giteaBusy()) update_.requestList();
+        else if (e.key == Key::Select && older_.selected() >= 0 && older_.selected() < static_cast<int>(olderReleases_.size()))
+            openRelease(olderReleases_[older_.selected()]);
+        return true;
+    }
+
    auto found = files();
    if (confirm_) {
        confirm_->onKey(e);
@@ -54,8 +133,22 @@ bool FirmwarePage::onKey(const KeyEvent& e) {
        case Key::Up: list_.up(); break;
        case Key::Down: list_.down(); break;
        case Key::Back: return false;
+        case Key::Char:
+            if ((e.ch == 'c' || e.ch == 'C') && !update_.giteaBusy()) update_.requestCheck();
+            break;
        case Key::Select:
-            if (list_.selected() >= kFixed) confirm_.reset(new DialogModel({"Cancel", "Install"}));
+            if (list_.selected() == kLatest) {
+                release::Release r;
+                if (update_.giteaBusy()) break;
+                if (update_.gitea().latest(r)) openRelease(r);
+                else update_.requestCheck();
+            } else if (list_.selected() == kOlder) {
+                view_ = View::Older;
+                if (olderReleases_.empty() && !update_.giteaBusy()) update_.requestList();
+            } else if (list_.selected() >= kFixed) {
+                ask_ = Ask::SdFile;
+                confirm_.reset(new DialogModel({"Cancel", "Install"}));
+            }
            break;
        default: break;
    }
@@ -63,6 +156,89 @@ bool FirmwarePage::onKey(const KeyEvent& e) {
 }

 void FirmwarePage::draw(Canvas& c) {
+    if (!message_.empty() && millis() - messageMs_ > 4000) message_.clear();
+    // What the last answer left: the list of older releases.
+    if (update_.gitea().seq() != olderSeq_ && !update_.giteaBusy()) {
+        olderSeq_ = update_.gitea().seq();
+        olderReleases_ = update_.gitea().list();
+        older_.setCount(static_cast<int>(olderReleases_.size()));
+    }
+    switch (view_) {
+        case View::Main: drawMain(c); break;
+        case View::Release: drawRelease(c); break;
+        case View::Older: drawOlder(c); break;
+    }
+    if (confirm_ && view_ != View::Main) {
+        std::string running = update_.runningVersion();
+        bool older = versionOlder(shown_.tag, running);
+        widgets::dialog(c, older ? "Go back?" : "Install update?",
+                        older ? shown_.tag + " is older than " + running + ". Install it anyway? The device restarts."
+                              : shown_.tag + " replaces " + running + ". The device restarts once it's written.",
+                        *confirm_);
+    }
+    if (!message_.empty() && !confirm_) {
+        c.setFont(&fonts::small);
+        c.setTextColor(theme::kWarning);
+        c.setTextDatum(top_left);
+        c.drawString(message_.c_str(), 4, theme::kContent.y + theme::kContent.h - 9);
+    }
+}
+
+void FirmwarePage::drawRelease(Canvas& c) {
+    const auto& area = theme::kContent;
+    std::string running = update_.runningVersion();
+    std::vector<std::string> lines;
+    lines.push_back(shown_.tag + (shown_.tag == running ? " (running)" : ""));
+    lines.push_back("Published " + shown_.date() + ", " + formatBytes(shown_.otaSize));
+    if (versionOlder(shown_.tag, running)) lines.push_back("Older than what's running");
+    auto measure = widgets::bodyMeasure(c);
+    lines.push_back("");
+    for (auto& l : wrapText(shown_.notes, area.w - 12, measure)) lines.push_back(l);
+    int rows = (area.h - 12) / theme::kLineHeight;
+    shownTop_ = std::clamp(shownTop_, 0, std::max(0, static_cast<int>(lines.size()) - rows));
+    widgets::textLines(c, lines, shownTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 12});
+
+    std::string why;
+    bool ok = installable(why);
+    c.setFont(&fonts::small);
+    c.setTextDatum(top_left);
+    c.setTextColor(theme::kMuted);
+    c.drawString(ok ? "Enter: install   c: check again" : (why + "   c: check again").c_str(), 4, area.y + area.h - 9);
+}
+
+void FirmwarePage::drawOlder(Canvas& c) {
+    const auto& area = theme::kContent;
+    GiteaReleases& g = update_.gitea();
+    c.setTextDatum(top_left);
+    if (update_.giteaBusy() || g.status() == GiteaReleases::Status::Busy) {
+        c.setFont(&fonts::body);
+        c.setTextColor(theme::kMuted);
+        c.drawString("Looking at the server...", 4, area.y + 4);
+        return;
+    }
+    if (olderReleases_.empty()) {
+        c.setFont(&fonts::body);
+        c.setTextColor(g.status() == GiteaReleases::Status::Failed ? theme::kWarning : theme::kMuted);
+        c.drawString(g.status() == GiteaReleases::Status::Failed ? g.error().c_str() : "No releases known.", 4, area.y + 4);
+        c.setFont(&fonts::small);
+        c.setTextColor(theme::kMuted);
+        c.drawString("c: look again", 4, area.y + area.h - 9);
+        return;
+    }
+    std::string running = update_.runningVersion();
+    widgets::list(
+        c, older_, {area.x, area.y, area.w, area.h - 11},
+        [&](int i) {
+            const auto& r = olderReleases_[i];
+            return r.tag + (r.tag == running ? "  (running)" : release::versionNewer(r.tag, running) ? "  (new)" : "");
+        },
+        [&](int i) { return olderReleases_[i].date(); });
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString("Enter: details   c: look again", 4, area.y + area.h - 9);
+}
+
+void FirmwarePage::drawMain(Canvas& c) {
    auto found = files();
    bool listed;
    {
@@ -78,6 +254,8 @@ void FirmwarePage::draw(Canvas& c) {
                case kVersion: return "Version";
                case kStatus: return "Status";
                case kAddress: return "Push to";
+                case kLatest: return "Latest release";
+                case kOlder: return "Older releases";
                case kSdHeader: return listed ? (found.empty() ? "No .ota files in /updates" : "On the SD card:") : "Looking on the SD card...";
                default: return "  " + found[i - kFixed].substr(std::string(kUpdatesFolder).size() + 1);
            }
@@ -87,6 +265,11 @@ void FirmwarePage::draw(Canvas& c) {
                case kVersion: return versionString();
                case kStatus: return update_.onProbation() ? "on probation" : "confirmed";
                case kAddress: return ip.empty() ? "Wi-Fi not connected" : ip + ":" + std::to_string(UpdateService::kPort);
+                case kLatest: {
+                    bool warn;
+                    return latestText(warn);
+                }
+                case kOlder: return ">";
                case kSdHeader: return "";
                default: return "install >";
            }
@@ -8,6 +8,7 @@
 #include "dialog_model.h"
 #include "key_event.h"
 #include "list_model.h"
+#include "release_info.h"
 #include "services/storage_service.h"
 #include "services/update_service.h"
 #include "services/wifi_service.h"
@@ -16,8 +17,9 @@

 namespace roro {

-// Settings → Firmware: the running version and its Probation, where to push Firmware Updates, and
-// the Update Files on the SD card (in /updates) to install from.
+// Settings → Firmware: the running version and its Probation, where to push Firmware Updates, the
+// project's releases on Gitea (the latest, and the ten before it), and the Update Files on the SD
+// card (in /updates) to install from.
 class FirmwarePage {
   public:
    FirmwarePage(UpdateService& update, WifiService& wifi, StorageService& storage)
@@ -28,15 +30,34 @@ class FirmwarePage {
    void draw(Canvas& c);

   private:
-    enum Row { kVersion, kStatus, kAddress, kSdHeader, kFixed };
+    enum Row { kVersion, kStatus, kAddress, kLatest, kOlder, kSdHeader, kFixed };
+    enum class View { Main, Release, Older };
+    enum class Ask { None, SdFile, Release };

    std::vector<std::string> files();
+    std::string latestText(bool& warn) const;
+    void openRelease(const release::Release& r);
+    bool installable(std::string& why) const;  // the shown release: can it be installed from here?
+    void drawMain(Canvas& c);
+    void drawRelease(Canvas& c);
+    void drawOlder(Canvas& c);
+    void say(const std::string& text);

    UpdateService& update_;
    WifiService& wifi_;
    StorageService& storage_;
    ListModel list_{theme::kContent.h / theme::kLineHeight};
+    ListModel older_{(theme::kContent.h - 11) / theme::kLineHeight};  // above the hint line
    std::unique_ptr<DialogModel> confirm_;
+    Ask ask_ = Ask::None;
+
+    View view_ = View::Main;
+    release::Release shown_;  // the release page
+    std::vector<release::Release> olderReleases_;
+    uint32_t olderSeq_ = 0;
+    int shownTop_ = 0;
+    std::string message_;
+    uint32_t messageMs_ = 0;

    // Filled on the storage task.
    std::mutex lock_;
@@ -71,10 +71,12 @@ void GnssApp::draw(Canvas& c) {
    if (!gnss_.on()) {
        c.setFont(&fonts::bold);
        c.setTextColor(theme::kText);
-        c.drawString("GNSS is off", 4, area.y + 4);
+        bool held = gnss_.heldForLora();
+        c.drawString(held ? "GNSS is paused" : "GNSS is off", 4, area.y + 4);
        c.setFont(&fonts::body);
        c.setTextColor(theme::kMuted);
-        c.drawString("Settings > GNSS turns it on.", 4, area.y + 22);
+        c.drawString(held ? "The LoRa radio is listening, and" : "Settings > GNSS turns it on.", 4, area.y + 22);
+        if (held) c.drawString("Settings pauses GNSS for it.", 4, area.y + 22 + theme::kLineHeight);
        return;
    }
    sky_ ? drawSky(c) : drawPosition(c);
@@ -16,7 +16,7 @@ const char* statusText(Status s) {
        case Status::Connecting: return "connecting...";
        case Status::Registering: return "logging in...";
        case Status::Online: return "";
-        case Status::Paused: return "paused (Wi-Fi monitoring)";
+        case Status::Paused: return "paused (Wi-Fi monitoring or an update)";
        case Status::Retrying: return "retrying soon";
    }
    return "";
@@ -1,4 +1,4 @@
-#include "storage_page.h"
+#include "maintenance_page.h"

 #include "ui/widgets.h"

@@ -9,25 +9,25 @@ constexpr int kAges = sizeof(kCleanupAgeLabels) / sizeof(kCleanupAgeLabels[0]);
 constexpr int kCategories = sizeof(kCleanupCategories) / sizeof(kCleanupCategories[0]);
 }  // namespace

-void StoragePage::enter() {
+void MaintenancePage::enter() {
    view_ = View::Main;
    dialog_.reset();
    main_.setCount(kRows);
    main_.select(kCleanUp);
 }

-void StoragePage::warn(const char* text) {
+void MaintenancePage::warn(const char* text) {
    bus_.publish(Event::withText(EventType::Notification, text, static_cast<int32_t>(NotificationLevel::Warning)));
 }

-uint64_t StoragePage::categoryBytes(int category) const {
+uint64_t MaintenancePage::categoryBytes(int category) const {
    uint64_t sum = 0;
    if (category < static_cast<int>(listing_.size()))
        for (auto& f : listing_[category]) sum += f.bytes;
    return sum;
 }

-CleanupPlan StoragePage::planFor(int age) const {
+CleanupPlan MaintenancePage::planFor(int age) const {
    int today = clock_.today();
    auto cutoff = static_cast<CleanupAge>(age);
    // Without a clock only "Everything" can be judged.
@@ -35,7 +35,7 @@ CleanupPlan StoragePage::planFor(int age) const {
    return CleanupPlan::make(listing_[categories_.selected()], cutoff, today);
 }

-bool StoragePage::onKey(const KeyEvent& e) {
+bool MaintenancePage::onKey(const KeyEvent& e) {
    if (dialog_) {
        dialog_->onKey(e);
        int result = dialog_->result();
@@ -109,7 +109,7 @@ bool StoragePage::onKey(const KeyEvent& e) {
    return true;
 }

-void StoragePage::draw(Canvas& c) {
+void MaintenancePage::draw(Canvas& c) {
    const auto& area = theme::kContent;
    if (!haveListing_ && storage_.listingReady()) {
        listing_ = storage_.listing();
@@ -15,10 +15,10 @@

 namespace roro {

-// Settings → Storage: card usage, Storage Clean-up (category → age → confirm) and erasing the card.
-class StoragePage {
+// Storage → Maintenance: card usage, Storage Clean-up (category → age → confirm) and erasing the card.
+class MaintenancePage {
   public:
-    StoragePage(StorageService& storage, ClockService& clock, EventBus& bus)
+    MaintenancePage(StorageService& storage, ClockService& clock, EventBus& bus)
        : storage_(storage), clock_(clock), bus_(bus) {}

    void enter();
@@ -0,0 +1,303 @@
+#include "note_editor.h"
+
+#include <Arduino.h>
+#include <SD.h>
+
+#include <ctime>
+
+#include "cleanup_plan.h"
+#include "file_list.h"
+#include "file_names.h"
+#include "ui/fonts.h"
+#include "ui/theme.h"
+#include "ui/widgets.h"
+
+namespace roro {
+
+using notes::NoteText;
+
+namespace {
+constexpr uint32_t kMessageMs = 4000;
+
+// One block the size of a full note, and something left: without it, nothing is opened. Free
+// memory in total isn't the measure: with IRC connected the largest free block is about 31 KB.
+constexpr size_t kRoomWanted = NoteText::kMaxBytes + 8 * 1024;
+const char* const kNoRoom = "Not enough memory to edit: close IRC or a Gemini page";
+
+// On the storage task. Reads a file of up to `limit` bytes into a string that has that capacity
+// already; false if it can't be read whole.
+bool readWhole(const std::string& path, std::string& into, size_t limit) {
+    File f = SD.open(path.c_str(), FILE_READ);
+    if (!f) return false;
+    size_t size = f.size();
+    if (size > limit) {
+        f.close();
+        return false;
+    }
+    into.resize(size);
+    size_t got = size ? f.read(reinterpret_cast<uint8_t*>(&into[0]), size) : 0;
+    f.close();
+    return got == size;
+}
+}  // namespace
+
+void NoteEditor::say(const std::string& text) {
+    message_ = text;
+    messageMs_ = millis();
+    redraw_ = true;
+}
+
+std::string NoteEditor::open(const std::string& path) {
+    close();
+    if (ESP.getMaxAllocHeap() < kRoomWanted) return kNoRoom;
+    std::string body, left, why;
+    body.reserve(NoteText::kMaxBytes);  // the note's own buffer from here on: read into, then handed over
+    bool ran = storage_.runAndWait([&]() {
+        File f = SD.open(path.c_str(), FILE_READ);
+        if (!f) {
+            why = "The card refused to open it";
+            return;
+        }
+        size_t size = f.size();
+        f.close();
+        if (size > NoteText::kMaxBytes) why = "Too big to edit: 16 KB at most";
+        else if (!readWhole(path, body, NoteText::kMaxBytes)) why = "The card refused to read it";
+        if (!why.empty()) return;
+        // A save that never finished: its temporary file is offered back (Q143), if there's the
+        // memory to look at it now. If not, it stays for the next time.
+        std::string tmp = path + ".tmp";
+        File t = SD.open(tmp.c_str(), FILE_READ);
+        if (!t) return;
+        size_t tmpSize = t.size();
+        t.close();
+        if (tmpSize > 0 && tmpSize <= NoteText::kMaxBytes && ESP.getMaxAllocHeap() < tmpSize + 8 * 1024) return;
+        left.reserve(tmpSize <= NoteText::kMaxBytes ? tmpSize : 0);
+        if (!readWhole(tmp, left, NoteText::kMaxBytes) || left == body || left.empty()) {
+            std::string().swap(left);
+            SD.remove(tmp.c_str());
+        }
+    });
+    if (!ran) return "No SD card";
+    if (!why.empty()) return why;
+    text_.reset(new NoteText(kCols, kRows, std::move(body)));
+    path_ = path;
+    folder_ = files::parentOf(path);
+    savedRevision_ = text_->revision();
+    problem_.clear();
+    message_.clear();
+    lastKeyMs_ = millis();
+    if (!left.empty()) {
+        recovered_ = std::move(left);
+        ask_ = Ask::Recover;
+        dialog_.reset(new DialogModel({"Keep the note", "Use the copy"}));
+    }
+    return "";
+}
+
+std::string NoteEditor::openNew(const std::string& folder) {
+    close();
+    if (ESP.getMaxAllocHeap() < kRoomWanted) return kNoRoom;
+    text_.reset(new NoteText(kCols, kRows));
+    path_.clear();
+    folder_ = folder;
+    savedRevision_ = text_->revision();
+    problem_.clear();
+    message_.clear();
+    lastKeyMs_ = millis();
+    return "";
+}
+
+void NoteEditor::close() {
+    if (dirty()) save();
+    text_.reset();
+    dialog_.reset();
+    ask_ = Ask::None;
+    std::string().swap(recovered_);
+}
+
+// On the main loop, waiting for the storage task: no second copy of the note is made, and at
+// 16 KB the wait is a fraction of a second, when nobody has typed for five.
+bool NoteEditor::save() {
+    if (!text_) return true;
+    lastTryMs_ = millis();
+    const std::string& body = text_->text();
+    if (path_.empty() && body.empty()) {  // a new note nothing was typed in: no file
+        savedRevision_ = text_->revision();
+        return true;
+    }
+    std::string path = path_, why;
+    if (path.empty()) {
+        char stamp[20] = "new";
+        int64_t now = clock_.utcNow();
+        if (now >= 0) {
+            time_t t = static_cast<time_t>(now);
+            struct tm local;
+            localtime_r(&t, &local);
+            std::snprintf(stamp, sizeof stamp, "%04d%02d%02d-%02d%02d", local.tm_year + 1900, local.tm_mon + 1, local.tm_mday, local.tm_hour,
+                          local.tm_min);
+        }
+        path = files::joinPath(folder_, notes::nameFromFirstLine(text_->firstLine(), stamp) + ".txt");
+    }
+    bool fresh = path_.empty();
+    bool ran = storage_.runAndWait([&]() {
+        if (!SD.exists(folder_.c_str()) && !SD.mkdir(folder_.c_str())) {
+            why = "the card refused to make " + folder_;
+            return;
+        }
+        if (fresh) {  // a name nothing has yet: "list (2).txt"
+            std::string name = files::baseName(path);
+            for (int n = 2; n < 100 && SD.exists(path.c_str()); n++) path = files::joinPath(folder_, files::copyName(name, n));
+        }
+        std::string tmp = path + ".tmp";
+        File f = SD.open(tmp.c_str(), FILE_WRITE);
+        if (!f) {
+            why = "the card refused to open a file";
+            return;
+        }
+        size_t wrote = body.empty() ? 0 : f.write(reinterpret_cast<const uint8_t*>(body.data()), body.size());
+        f.close();
+        File check = SD.open(tmp.c_str(), FILE_READ);
+        bool whole = wrote == body.size() && check && check.size() == body.size();
+        if (check) check.close();
+        if (!whole) {
+            SD.remove(tmp.c_str());
+            why = "the card refused a write";
+            return;
+        }
+        // FAT can't rename onto a file. Between these two lines only the temporary file exists:
+        // the Notes list puts such a file back under its name.
+        if (SD.exists(path.c_str())) SD.remove(path.c_str());
+        if (!SD.rename(tmp.c_str(), path.c_str())) why = "the card refused to rename the file";
+    });
+    if (!ran) why = "no SD card";
+    if (!why.empty()) {
+        if (problem_ != why) say("Not saved: " + why);
+        problem_ = why;
+        return false;
+    }
+    path_ = path;
+    problem_.clear();
+    savedRevision_ = text_->revision();
+    redraw_ = true;
+    return true;
+}
+
+bool NoteEditor::onKey(const KeyEvent& e) {
+    if (!text_) return false;
+    redraw_ = true;
+    if (dialog_) {
+        dialog_->onKey(e);
+        int result = dialog_->result();
+        if (result == DialogModel::kPending) return true;
+        Ask asked = ask_;
+        ask_ = Ask::None;
+        dialog_.reset();
+        if (asked == Ask::Recover) {
+            if (result == 1) {
+                if (text_->setText(recovered_)) say("The unsaved copy is back");  // different from the card: saved in five seconds
+                else say("That copy is too big to edit");
+            } else {
+                std::string tmp = path_ + ".tmp";
+                storage_.runJob([tmp]() { SD.remove(tmp.c_str()); });
+            }
+            std::string().swap(recovered_);
+            return true;
+        }
+        if (asked == Ask::LeaveUnsaved && result == 1) {
+            savedRevision_ = text_->revision();  // given up on
+            return false;
+        }
+        return true;
+    }
+    lastKeyMs_ = millis();
+    bool page = e.shift || e.alt;
+    switch (e.key) {
+        case Key::Char: {
+            uint32_t lower = e.ch >= 'A' && e.ch <= 'Z' ? e.ch + 32 : e.ch;
+            if (e.ctrl) {
+                if (lower == 'a') text_->lineStart();
+                else if (lower == 'e') text_->lineEnd();
+                break;
+            }
+            if (!text_->insert(e.ch)) say("This note is full: 16 KB");
+            break;
+        }
+        case Key::Select:
+            if (!text_->insert('\n')) say("This note is full: 16 KB");
+            break;
+        case Key::Tab:
+            if (!text_->insertText("  ")) say("This note is full: 16 KB");
+            break;
+        case Key::Delete: text_->backspace(); break;
+        case Key::Left: text_->left(); break;
+        case Key::Right: text_->right(); break;
+        case Key::Up: page ? text_->pageUp() : text_->up(); break;
+        case Key::Down: page ? text_->pageDown() : text_->down(); break;
+        case Key::Back:
+            if (!dirty() || save()) return false;
+            ask_ = Ask::LeaveUnsaved;
+            dialog_.reset(new DialogModel({"Stay", "Leave"}));
+            break;
+        default: break;
+    }
+    return true;
+}
+
+bool NoteEditor::update(uint32_t) {
+    if (!text_) return false;
+    uint32_t now = millis();
+    // A save that failed is tried again every five seconds, not at every pass.
+    if (dirty() && !dialog_ && now - lastTryMs_ >= kSaveAfterMs &&
+        (now - lastKeyMs_ >= kSaveAfterMs || power_.screen() == ScreenState::Off))
+        save();
+    if (!message_.empty() && now - messageMs_ >= kMessageMs) {
+        message_.clear();
+        redraw_ = true;
+    }
+    bool r = redraw_;
+    redraw_ = false;
+    return r;
+}
+
+void NoteEditor::draw(Canvas& c) {
+    if (!text_) return;
+    const auto& area = theme::kContent;
+    c.setTextDatum(top_left);
+
+    // The name, and whether the card has what's on screen.
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    std::string name = path_.empty() ? "New note" : files::fitName(files::baseName(path_), 26);
+    c.drawString(name.c_str(), 4, area.y + 1);
+    std::string state = formatBytes(text_->text().size()) + (dirty() ? (problem_.empty() ? ", typing" : ", NOT SAVED") : ", saved");
+    if (path_.empty() && !dirty()) state = "empty";
+    c.setTextDatum(top_right);
+    c.setTextColor(dirty() && !problem_.empty() ? theme::kWarning : theme::kMuted);
+    c.drawString(state.c_str(), area.w - 3, area.y + 1);
+    c.setTextDatum(top_left);
+
+    int top = area.y + 10;
+    auto rows = text_->rows();
+    c.setFont(&fonts::body);
+    c.setTextColor(theme::kText);
+    for (size_t i = 0; i < rows.size(); i++) c.drawString(rows[i].c_str(), 4, top + 1 + static_cast<int>(i) * theme::kLineHeight);
+    c.fillRect(3 + text_->cursorCol() * 6, top + text_->cursorRow() * theme::kLineHeight, 1, theme::kLineHeight, theme::kAccent);
+    if (text_->text().size() > static_cast<size_t>(kCols * kRows)) {  // more than a screen: where we are in it
+        int h = kRows * theme::kLineHeight, barH = 12;
+        c.fillRect(area.w - 2, top + (h - barH) * text_->percent() / 100, 2, barH, theme::kMuted);
+    }
+
+    c.setFont(&fonts::small);
+    bool showMessage = !message_.empty() && millis() - messageMs_ < kMessageMs;
+    c.setTextColor(showMessage ? theme::kWarning : theme::kMuted);
+    c.drawString(showMessage ? message_.c_str() : "Fn+arrows: move  Ctrl+A/E: line  Back: done", 4, area.y + area.h - 9);
+
+    if (dialog_ && ask_ == Ask::Recover)
+        widgets::dialog(c, "Unsaved copy", "A save of this note was cut short. Its copy has " + formatBytes(recovered_.size()) + ", the note " +
+                                               formatBytes(text_->text().size()) + ".",
+                        *dialog_);
+    else if (dialog_)
+        widgets::dialog(c, "Not saved", "The note couldn't be saved: " + problem_ + ". Leave and lose what was typed?", *dialog_);
+}
+
+}  // namespace roro
@@ -0,0 +1,60 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "dialog_model.h"
+#include "key_event.h"
+#include "note_text.h"
+#include "services/clock_service.h"
+#include "services/power_service.h"
+#include "services/storage_service.h"
+#include "ui/canvas.h"
+
+namespace roro {
+
+// Edits one text file of up to 16 KB (F1, Q143-Q145): the Notes App's editor, and the Storage
+// App's for `e`. It saves by itself: five seconds after the last key, when the screen turns off,
+// and on close. A save writes `<file>.tmp`, then puts it in the note's place, so the note on the
+// card is always a whole one.
+class NoteEditor {
+   public:
+    static constexpr int kCols = 38, kRows = 8;
+    static constexpr uint32_t kSaveAfterMs = 5000;
+
+    NoteEditor(StorageService& storage, ClockService& clock, PowerService& power)
+        : storage_(storage), clock_(clock), power_(power) {}
+
+    std::string open(const std::string& path);  // "" or why it can't be edited
+    std::string openNew(const std::string& folder);  // the same; no file until there's something to save (Q142)
+    void close();                               // saves what isn't yet
+    bool isOpen() const { return static_cast<bool>(text_); }
+    const std::string& path() const { return path_; }  // "" for a new note nothing was typed in
+
+    bool onKey(const KeyEvent& e);  // false: done, and saved
+    bool update(uint32_t nowMs);    // true: draw again
+    void draw(Canvas& c);
+
+   private:
+    enum class Ask { None, Recover, LeaveUnsaved };
+
+    bool dirty() const { return text_ && text_->revision() != savedRevision_; }
+    bool save();  // true if the card has it now (or there was nothing to save)
+    void say(const std::string& text);
+
+    StorageService& storage_;
+    ClockService& clock_;
+    PowerService& power_;
+    std::unique_ptr<notes::NoteText> text_;
+    std::string path_, folder_;
+    uint32_t savedRevision_ = 0, lastKeyMs_ = 0, lastTryMs_ = 0;
+    std::string recovered_;  // what a temporary file left behind holds, until the user has chosen
+    Ask ask_ = Ask::None;
+    std::unique_ptr<DialogModel> dialog_;
+    std::string message_, problem_;
+    uint32_t messageMs_ = 0;
+    bool redraw_ = false;
+};
+
+}  // namespace roro
@@ -0,0 +1,346 @@
+#include "notes_app.h"
+
+#include <Arduino.h>
+#include <SD.h>
+
+#include <algorithm>
+#include <cstring>
+
+#include "file_names.h"
+#include "ui/canvas.h"
+#include "ui/fonts.h"
+#include "ui/widgets.h"
+
+namespace roro {
+
+using files::baseName;
+using files::joinPath;
+
+namespace {
+constexpr uint32_t kMessageMs = 4000;
+constexpr size_t kTitleChars = 26;
+
+bool endsWith(const std::string& s, const char* tail) {
+    size_t n = std::strlen(tail);
+    return s.size() >= n && s.compare(s.size() - n, n, tail) == 0;
+}
+}  // namespace
+
+void NotesApp::onEnter() {
+    view_ = ESP.getFreeHeap() < kStartFloor ? View::NoMemory : View::List;
+    dialog_.reset();
+    message_.clear();
+    cardPresent_ = storage_.state().present;
+    mended_ = false;
+    if (view_ == View::List) reload();
+    requestRedraw();
+}
+
+void NotesApp::onExit() {
+    editor_.close();  // saves
+    if (wait_ == Wait::List) ops_.cancel();
+    wait_ = Wait::None;
+    wantList_ = loaded_ = false;
+    list_ = files::FileList();
+    std::vector<uint16_t>().swap(notes_);
+    std::vector<std::string>().swap(titles_);
+    titlesFrom_ = -1;
+    rows_.setCount(0);
+}
+
+void NotesApp::say(const std::string& text) {
+    message_ = text;
+    messageMs_ = millis();
+    requestRedraw();
+}
+
+void NotesApp::reload(const std::string& select) {
+    selectAfter_ = select;
+    wantList_ = true;
+}
+
+std::string NotesApp::selectedPath() const {
+    int i = rows_.selected();
+    if (!loaded_ || i < 0 || i >= static_cast<int>(notes_.size())) return "";
+    return joinPath(kFolder, list_.name(notes_[i]));
+}
+
+void NotesApp::leaveEditor() {
+    std::string path = editor_.path();
+    editor_.close();
+    view_ = View::List;
+    reload(path.empty() ? "" : baseName(path));
+}
+
+void NotesApp::update(uint32_t nowMs) {
+    bool present = storage_.state().present;
+    if (present != cardPresent_) {
+        cardPresent_ = present;
+        if (view_ == View::Name) view_ = View::List;
+        loaded_ = false;
+        wantList_ = present && view_ == View::List;
+        requestRedraw();
+    }
+    if (view_ == View::Edit) {
+        if (editor_.update(nowMs)) requestRedraw();
+        return;
+    }
+    if (wantList_ && present && wait_ == Wait::None && !ops_.busy() && ops_.list(kFolder).empty()) {
+        wantList_ = false;
+        wait_ = Wait::List;
+    }
+    FileOps::Status s;
+    if (wait_ != Wait::None && ops_.finished(s)) {
+        onFinished(s);
+        requestRedraw();
+    }
+    if (!message_.empty() && millis() - messageMs_ >= kMessageMs) {
+        message_.clear();
+        requestRedraw();
+    }
+}
+
+void NotesApp::onFinished(const FileOps::Status& s) {
+    Wait was = wait_;
+    wait_ = Wait::None;
+    if (was == Wait::Work) {
+        if (!s.error.empty()) say(s.error);
+        else say(s.op == FileOps::Op::Delete ? "Deleted" : "Renamed");
+        return reload(selectAfter_);
+    }
+    list_.clear();
+    notes_.clear();
+    if (s.error.empty()) {  // no /notes yet is an empty list, not an error
+        ops_.takeListing(list_);
+        list_.sort(sort_);
+    }
+    // A save cut between its two last steps left "x.txt.tmp" and no "x.txt": the whole note, under
+    // the wrong name. Put back once, then listed again.
+    std::vector<std::string> orphans;
+    for (size_t i = 0; i < list_.count(); i++) {
+        std::string name = list_.name(i);
+        if (list_.folder(i)) continue;
+        if (endsWith(name, ".tmp")) {
+            if (list_.find(name.substr(0, name.size() - 4)) < 0) orphans.push_back(name);
+            continue;
+        }
+        notes_.push_back(static_cast<uint16_t>(i));
+    }
+    if (!orphans.empty() && !mended_) {
+        mended_ = true;
+        storage_.runAndWait([&]() {
+            for (auto& name : orphans) {
+                std::string from = joinPath(kFolder, name);
+                SD.rename(from.c_str(), from.substr(0, from.size() - 4).c_str());
+            }
+        });
+        return reload(selectAfter_);
+    }
+    loaded_ = true;
+    titlesFrom_ = -1;
+    rows_.setCount(static_cast<int>(notes_.size()));
+    int at = -1;
+    for (size_t i = 0; i < notes_.size() && !selectAfter_.empty(); i++)
+        if (selectAfter_ == list_.name(notes_[i])) at = static_cast<int>(i);
+    rows_.select(at >= 0 ? at : selectIndex_);
+    selectAfter_.clear();
+    selectIndex_ = 0;
+}
+
+// The first line of each note on screen, read when the list moves: eight short reads.
+void NotesApp::readTitles() {
+    if (titlesFrom_ == rows_.firstVisible()) return;
+    titlesFrom_ = rows_.firstVisible();
+    titles_.clear();
+    std::vector<std::string> paths;
+    for (int i = titlesFrom_; i < titlesFrom_ + kRows && i < static_cast<int>(notes_.size()); i++) paths.push_back(joinPath(kFolder, list_.name(notes_[i])));
+    titles_.resize(paths.size());
+    storage_.runAndWait([&]() {
+        for (size_t i = 0; i < paths.size(); i++) {
+            File f = SD.open(paths[i].c_str(), FILE_READ);
+            if (!f) continue;
+            char head[120];
+            int n = f.read(reinterpret_cast<uint8_t*>(head), sizeof head);
+            f.close();
+            if (n > 0) titles_[i] = notes::titleFrom(std::string(head, n), kTitleChars);
+        }
+    });
+}
+
+std::string NotesApp::titleOf(int row) {
+    size_t i = static_cast<size_t>(row - titlesFrom_);
+    if (i < titles_.size() && !titles_[i].empty()) return titles_[i];
+    return files::fitName(list_.name(notes_[row]), kTitleChars);  // an empty note, or not a text
+}
+
+bool NotesApp::onKey(const KeyEvent& e) {
+    requestRedraw();
+    if (view_ == View::NoMemory) return false;
+    if (view_ == View::Edit) {
+        if (!editor_.onKey(e)) leaveEditor();
+        return true;
+    }
+    if (dialog_) {
+        dialog_->onKey(e);
+        int result = dialog_->result();
+        if (result == DialogModel::kPending) return true;
+        dialog_.reset();
+        if (result == 1) {
+            selectIndex_ = rows_.selected();
+            selectAfter_.clear();
+            std::string why = ops_.remove(target_, false);
+            if (why.empty()) wait_ = Wait::Work;
+            else say(why);
+        }
+        return true;
+    }
+    if (wantList_ || wait_ != Wait::None) return true;  // a moment
+    if (view_ == View::Name) return onNameKey(e);
+    return onListKey(e);
+}
+
+bool NotesApp::onNameKey(const KeyEvent& e) {
+    switch (e.key) {
+        case Key::Char: name_.insert(e.ch); break;
+        case Key::Delete: name_.backspace(); break;
+        case Key::Left: name_.left(); break;
+        case Key::Right: name_.right(); break;
+        case Key::Back: view_ = View::List; break;
+        case Key::Select: {
+            std::string name = name_.text() + ".txt";
+            std::string why = files::checkName(name);
+            if (why.empty() && name != baseName(target_)) {
+                why = ops_.move(target_, false, joinPath(kFolder, name));
+                if (why.empty()) {
+                    wait_ = Wait::Work;
+                    selectAfter_ = name;
+                }
+            }
+            if (why.empty()) view_ = View::List;
+            else say(why);
+            break;
+        }
+        default: break;
+    }
+    return true;
+}
+
+bool NotesApp::onListKey(const KeyEvent& e) {
+    if (e.key == Key::Back) return false;
+    if (!cardPresent_ || !loaded_) return true;
+    uint32_t ch = e.key == Key::Char ? (e.ch >= 'A' && e.ch <= 'Z' ? e.ch + 32 : e.ch) : 0;
+    std::string path = selectedPath();
+    switch (e.key) {
+        case Key::Up: rows_.up(); return true;
+        case Key::Down: rows_.down(); return true;
+        case Key::Left: rows_.pageUp(); return true;
+        case Key::Right: rows_.pageDown(); return true;
+        case Key::Select: {
+            if (path.empty()) return true;
+            std::string why = editor_.open(path);
+            if (why.empty()) view_ = View::Edit;
+            else say(why);
+            return true;
+        }
+        case Key::Delete: ch = 'd'; break;
+        default: break;
+    }
+    if (ch == 'n') {
+        std::string why = editor_.openNew(kFolder);
+        if (why.empty()) view_ = View::Edit;
+        else say(why);
+    } else if (ch == 's') {
+        sort_ = sort_ == files::FileSort::Date ? files::FileSort::Name : files::FileSort::Date;
+        std::string keep = path.empty() ? "" : baseName(path);
+        list_.sort(sort_);
+        notes_.clear();
+        for (size_t i = 0; i < list_.count(); i++)
+            if (!list_.folder(i) && !endsWith(list_.name(i), ".tmp")) notes_.push_back(static_cast<uint16_t>(i));
+        for (size_t i = 0; i < notes_.size(); i++)
+            if (keep == list_.name(notes_[i])) rows_.select(static_cast<int>(i));
+        titlesFrom_ = -1;
+        say(sort_ == files::FileSort::Date ? "Newest first" : "By file name");
+    } else if (path.empty()) {
+        // nothing selected: the keys below need a note
+    } else if (ch == 'd') {
+        target_ = path;
+        question_ = "Delete " + files::fitName(baseName(path), 22) + ", \"" + titleOf(rows_.selected()).substr(0, 20) + "\"? It can't be undone.";
+        dialog_.reset(new DialogModel({"Cancel", "Delete"}));
+    } else if (ch == 'r') {
+        target_ = path;
+        std::string name = baseName(path);
+        size_t dot = name.rfind('.');
+        name_.setText(dot == std::string::npos || dot == 0 ? name : name.substr(0, dot));
+        view_ = View::Name;
+    }
+    return true;
+}
+
+void NotesApp::draw(Canvas& c) {
+    lastDrawMs_ = millis();
+    const auto& area = theme::kContent;
+    c.setTextDatum(top_left);
+    if (view_ == View::NoMemory) {
+        c.setFont(&fonts::bold);
+        c.setTextColor(theme::kWarning);
+        c.drawString("Not enough memory", 4, area.y + 4);
+        c.setFont(&fonts::body);
+        c.setTextColor(theme::kMuted);
+        c.drawString("Close what's running (IRC, a page", 4, area.y + 22);
+        c.drawString("in Gemini) and open Notes again.", 4, area.y + 22 + theme::kLineHeight);
+        return;
+    }
+    if (view_ == View::Edit) return editor_.draw(c);
+
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString(kFolder, 4, area.y + 1);
+    if (loaded_) {
+        std::string count = std::to_string(notes_.size()) + (notes_.size() == 1 ? " note" : " notes");
+        if (list_.more() > 0) count = "the first " + std::to_string(notes_.size()) + " notes";
+        c.setTextDatum(top_right);
+        c.drawString(count.c_str(), area.w - 3, area.y + 1);
+        c.setTextDatum(top_left);
+    }
+
+    theme::Rect rows{area.x, area.y + 10, area.w, kRows * theme::kLineHeight};
+    c.setFont(&fonts::body);
+    if (!storage_.state().present) {
+        c.setTextColor(theme::kWarning);
+        c.drawString("No SD card", 4, rows.y + 4);
+        c.setTextColor(theme::kMuted);
+        c.drawString("Notes are kept on the card.", 4, rows.y + 4 + theme::kLineHeight);
+    } else if (!loaded_) {
+        // a moment
+    } else if (notes_.empty()) {
+        c.setTextColor(theme::kMuted);
+        c.drawString("No notes yet.", 4, rows.y + 4);
+        c.drawString("n starts one.", 4, rows.y + 4 + theme::kLineHeight);
+    } else {
+        readTitles();
+        widgets::list(
+            c, rows_, rows, [&](int i) { return titleOf(i); },
+            [&](int i) {
+                std::string stamp = files::formatStamp(list_.modified(notes_[i]));
+                return stamp.size() >= 10 ? stamp.substr(0, 10) : stamp;
+            });
+    }
+
+    c.setFont(&fonts::small);
+    bool showMessage = !message_.empty() && millis() - messageMs_ < kMessageMs;
+    c.setTextColor(showMessage ? theme::kWarning : theme::kMuted);
+    c.drawString(showMessage ? message_.c_str() : "n: new  Enter: open  r: name  d: del  s: sort", 4, area.y + area.h - 9);
+
+    if (view_ == View::Name) {
+        theme::Rect box{16, 44, theme::kWidth - 32, 48};
+        c.fillRect(box.x, box.y, box.w, box.h, theme::kBackground);
+        c.drawRect(box.x, box.y, box.w, box.h, theme::kAccent);
+        c.setFont(&fonts::bold);
+        c.setTextColor(theme::kText);
+        c.drawString("File name (.txt)", box.x + 6, box.y + 4);
+        widgets::lineEditor(c, name_, {box.x + 6, box.y + 22, box.w - 12, theme::kLineHeight + 4});
+    }
+    if (dialog_) widgets::dialog(c, "Delete", question_, *dialog_);
+}
+
+}  // namespace roro
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "app.h"
+#include "apps/note_editor.h"
+#include "dialog_model.h"
+#include "file_list.h"
+#include "line_editor.h"
+#include "list_model.h"
+#include "services/file_ops.h"
+#include "ui/theme.h"
+
+namespace roro {
+
+// Notes (docs/milestones/F1.md, Q141-Q150): plain text files in /notes, listed by their first line,
+// newest first. n starts one, Enter opens it in the editor, which saves by itself; r renames the
+// file, d deletes it after asking, s sorts by name or by date.
+class NotesApp : public App {
+   public:
+    NotesApp(FileOps& ops, StorageService& storage, ClockService& clock, PowerService& power)
+        : ops_(ops), storage_(storage), editor_(storage, clock, power) {}
+    void onEnter() override;
+    void onExit() override;
+    bool onKey(const KeyEvent& e) override;
+    bool textEntryActive() const override { return view_ == View::Edit || view_ == View::Name; }
+    void update(uint32_t nowMs) override;
+    void draw(Canvas& c) override;
+
+   private:
+    enum class View { List, Edit, Name, NoMemory };
+    enum class Wait { None, List, Work };
+    static constexpr int kRows = 8;
+    static constexpr size_t kStartFloor = 55 * 1024;  // Q86, Q144
+    static constexpr const char* kFolder = "/notes";
+
+    void reload(const std::string& select = "");
+    void onFinished(const FileOps::Status& s);
+    bool onListKey(const KeyEvent& e);
+    bool onNameKey(const KeyEvent& e);
+    void leaveEditor();
+    std::string selectedPath() const;  // "" in an empty list
+    std::string titleOf(int row);
+    void readTitles();
+    void say(const std::string& text);
+
+    FileOps& ops_;
+    StorageService& storage_;
+    NoteEditor editor_;
+
+    View view_ = View::List;
+    files::FileList list_;
+    std::vector<uint16_t> notes_;  // the entries of list_ that are notes
+    files::FileSort sort_ = files::FileSort::Date;
+    ListModel rows_{kRows};
+    bool wantList_ = false, loaded_ = false, cardPresent_ = false, mended_ = false;
+    std::string selectAfter_;
+    int selectIndex_ = 0;
+    Wait wait_ = Wait::None;
+    std::vector<std::string> titles_;  // of the rows on screen
+    int titlesFrom_ = -1;
+    std::unique_ptr<DialogModel> dialog_;
+    std::string target_, question_;
+    LineEditor name_{40};
+    std::string message_;
+    uint32_t messageMs_ = 0, lastDrawMs_ = 0;
+};
+
+}  // namespace roro
@@ -27,9 +27,6 @@ bool SettingsApp::onKey(const KeyEvent& e) {
        case Page::Menu: return onMenuKey(e);
        case Page::Text: return onTextKey(e);
        case Page::Choice: return onChoiceKey(e);
-        case Page::Storage:
-            if (!storagePage_.onKey(e)) page_ = Page::Menu;
-            return true;
        case Page::About: return onAboutKey(e);
        case Page::Wifi:
            if (!wifiPage_.onKey(e)) page_ = Page::Menu;
@@ -70,10 +67,6 @@ bool SettingsApp::onMenuKey(const KeyEvent& e) {
        case Kind::Slider: break;
        case Kind::Page:
            switch (menu_.row(i)) {
-                case Row::Storage:
-                    page_ = Page::Storage;
-                    storagePage_.enter();
-                    break;
                case Row::Wifi:
                    page_ = Page::Wifi;
                    wifiPage_.enter();
@@ -130,8 +123,8 @@ bool SettingsApp::onAboutKey(const KeyEvent& e) {
 }

 void SettingsApp::update(uint32_t nowMs) {
-    // Live values on Storage and About.
-    bool live = page_ == Page::Storage || page_ == Page::About || page_ == Page::Firmware ||
+    // Live values on About and Firmware.
+    bool live = page_ == Page::About || page_ == Page::Firmware ||
                (page_ == Page::Wifi && wifiPage_.live());
    if (live && nowMs - lastRefreshMs_ >= 500) {
        lastRefreshMs_ = nowMs;
@@ -188,7 +181,6 @@ void SettingsApp::draw(Canvas& c) {
            widgets::list(c, choices_, area, [&](int i) { return (i == current ? "* " : "  ") + options[i]; });
            break;
        }
-        case Page::Storage: storagePage_.draw(c); break;
        case Page::About: widgets::textLines(c, aboutLines(), 0, area); break;
        case Page::Wifi: wifiPage_.draw(c); break;
        case Page::Firmware: firmwarePage_.draw(c); break;
@@ -14,7 +14,6 @@
 #include "services/clock_service.h"
 #include "services/storage_service.h"
 #include "apps/firmware_page.h"
-#include "apps/storage_page.h"
 #include "apps/wifi_settings_page.h"
 #include "settings_menu.h"
 #include "ui/theme.h"
@@ -33,14 +32,13 @@ struct SettingsAppDeps {
    UpdateService& update;
 };

-// Settings: every user-facing setting, plus the Storage and About pages.
+// Settings: every user-facing setting, plus the Wi-Fi, Firmware and About pages.
 class SettingsApp : public App {
   public:
    explicit SettingsApp(const SettingsAppDeps& deps)
        : d_(deps),
          menu_(deps.settings),
          wifiPage_(deps.settings, deps.savedNetworks, deps.wifi, deps.bus),
-          storagePage_(deps.storage, deps.clock, deps.bus),
          firmwarePage_(deps.update, deps.wifi, deps.storage) {}
    void onEnter() override;
    bool onKey(const KeyEvent& e) override;
@@ -51,7 +49,7 @@ class SettingsApp : public App {
    void draw(Canvas& c) override;

   private:
-    enum class Page { Menu, Text, Choice, Storage, About, Wifi, Firmware };
+    enum class Page { Menu, Text, Choice, About, Wifi, Firmware };

    bool onMenuKey(const KeyEvent& e);
    bool onTextKey(const KeyEvent& e);
@@ -63,7 +61,6 @@ class SettingsApp : public App {
    SettingsAppDeps d_;
    SettingsMenu menu_;
    WifiSettingsPage wifiPage_;
-    StoragePage storagePage_;
    FirmwarePage firmwarePage_;
    Page page_ = Page::Menu;
    ListModel list_{theme::kContent.h / theme::kLineHeight};
@@ -0,0 +1,596 @@
+#include "storage_app.h"
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <cstdio>
+
+#include "cleanup_plan.h"
+#include "file_names.h"
+#include "ui/canvas.h"
+#include "ui/fonts.h"
+#include "ui/widgets.h"
+
+namespace roro {
+
+using files::baseName;
+using files::joinPath;
+using files::parentOf;
+
+namespace {
+constexpr uint32_t kMessageMs = 4000;
+constexpr uint32_t kQuietMs = 300;  // an operation shorter than this shows no progress
+
+const char* kindText(const std::string& name) {
+    switch (files::kindOf(name)) {
+        case files::FileKind::Text: return "Text";
+        case files::FileKind::Gpx: return "Track (GPX)";
+        case files::FileKind::Pcap: return "Capture (pcap)";
+        case files::FileKind::Ota: return "Update File";
+        default: return "File";
+    }
+}
+
+std::string plural(uint32_t n, const char* one) { return std::to_string(n) + " " + one + (n == 1 ? "" : "s"); }
+}  // namespace
+
+void StorageApp::onEnter() {
+    view_ = ESP.getFreeHeap() < kStartFloor ? View::NoMemory : View::Browse;
+    ask_ = Ask::None;
+    dialog_.reset();
+    message_.clear();
+    cardPresent_ = storage_.state().present;
+    // A copy left running is picked up where it is; anything else starts from a fresh listing.
+    if (wait_ != Wait::Work && view_ == View::Browse) open(cwd_);
+    else want_ = cwd_;
+    requestRedraw();
+}
+
+void StorageApp::onExit() {
+    if (wait_ != Wait::None && wait_ != Wait::Work) {
+        ops_.cancel();
+        wait_ = Wait::None;
+    }
+    noteEditor_.close();  // saves
+    viewer_.close();
+    wantList_ = false;
+    loaded_ = false;
+    list_ = files::FileList();  // its memory only while the App is open
+    rows_.setCount(0);
+    std::vector<std::string>().swap(details_);
+}
+
+void StorageApp::say(const std::string& text) {
+    message_ = text;
+    messageMs_ = millis();
+    requestRedraw();
+}
+
+// What's on screen stays, with its path, until the new listing is in: cwd_ changes then.
+void StorageApp::open(const std::string& folder, const std::string& select) {
+    want_ = folder;
+    selectAfter_ = select;
+    wantList_ = true;  // started from update(), once the card is free
+    waitSinceMs_ = millis();
+}
+
+StorageApp::Item StorageApp::selected() const {
+    int i = rows_.selected();
+    if (!loaded_ || i < 0 || i >= static_cast<int>(list_.count())) return {};
+    Item item;
+    item.path = joinPath(cwd_, list_.name(i));
+    item.folder = list_.folder(i);
+    return item;
+}
+
+bool StorageApp::work(const std::string& why, const std::string& selectAfter) {
+    if (!why.empty()) {
+        say(why);
+        return false;
+    }
+    wait_ = Wait::Work;
+    waitSinceMs_ = millis();
+    selectAfter_ = selectAfter;
+    return true;
+}
+
+void StorageApp::update(uint32_t nowMs) {
+    bool present = storage_.state().present;
+    if (present != cardPresent_) {  // taken out, put in, or erased: back to the top
+        cardPresent_ = present;
+        cwd_ = want_ = "/";
+        selectAfter_.clear();
+        loaded_ = false;
+        list_.clear();
+        rows_.setCount(0);
+        wantList_ = present;
+        clip_ = Item();
+        if (view_ == View::Viewer) viewer_.close();
+        if (view_ == View::Editor) noteEditor_.close();
+        if (view_ == View::Details || view_ == View::Name || view_ == View::Viewer || view_ == View::Editor) view_ = View::Browse;
+        requestRedraw();
+    }
+    if (wantList_ && present && wait_ == Wait::None && !ops_.busy() && ops_.list(want_).empty()) {
+        wantList_ = false;
+        wait_ = Wait::List;
+        waitSinceMs_ = nowMs;
+    }
+    if (view_ == View::Viewer && viewer_.update(nowMs)) requestRedraw();
+    if (view_ == View::Editor && noteEditor_.update(nowMs)) requestRedraw();
+    FileOps::Status s;
+    if (wait_ != Wait::None && ops_.finished(s)) {
+        onFinished(s);
+        requestRedraw();
+    }
+    // millis(), not nowMs: a message set by a key in this same pass is newer than the pass's own time.
+    uint32_t now = millis();
+    if ((wait_ != Wait::None || wantList_) && now - lastDrawMs_ >= 250) requestRedraw();
+    if (!message_.empty() && now - messageMs_ >= kMessageMs) {
+        message_.clear();
+        requestRedraw();
+    }
+    if (view_ == View::Maintenance && now - lastDrawMs_ >= 1000) requestRedraw();
+}
+
+void StorageApp::onFinished(const FileOps::Status& s) {
+    Wait was = wait_;
+    wait_ = Wait::None;
+    switch (was) {
+        case Wait::List: {
+            if (!s.error.empty()) {
+                say(s.error);
+                selectAfter_.clear();
+                // A folder that can't be opened leaves the screen as it is; if it's the one on
+                // screen that went away, back to the top.
+                if (want_ != cwd_ && loaded_) {
+                    want_ = cwd_;
+                    return;
+                }
+                if (want_ != "/") return open("/");
+                list_.clear();
+            } else {
+                ops_.takeListing(list_);
+                list_.sort(sort_);
+            }
+            cwd_ = want_;
+            loaded_ = true;
+            int count = static_cast<int>(list_.count()) + (cwd_ == "/" ? 1 : 0);
+            int at = selectAfter_.empty() ? -1 : list_.find(selectAfter_);
+            rows_.setCount(count);
+            rows_.select(at >= 0 ? at : selectIndex_);
+            selectAfter_.clear();
+            selectIndex_ = 0;
+            break;
+        }
+        case Wait::CountToDelete:
+            if (!s.error.empty()) say(s.error);
+            else if (!s.cancelled) askDelete(target_, s.files, s.bytes);
+            break;
+        case Wait::CountForDetails:
+            if (view_ != View::Details || details_.empty() || s.cancelled) break;
+            details_.back() = s.error.empty() ? plural(s.files, "file") + ", " + formatBytes(s.bytes) : s.error;
+            break;
+        case Wait::Work: {
+            std::string name = files::fitName(baseName(target_.path), 20);
+            if (s.exists && pasting_) {
+                question_ = name + " exists already in this folder. Replace it?";
+                ask_ = Ask::Replace;
+                dialog_.reset(new DialogModel({"Cancel", "Replace"}));
+                return;
+            }
+            if (!s.error.empty()) say(s.error);
+            else if (s.cancelled) say(s.op == FileOps::Op::Copy ? "Cancelled: nothing was copied" : "Cancelled after " + plural(s.files, "file"));
+            else {
+                switch (s.op) {
+                    case FileOps::Op::Copy: say(s.files == 1 ? "Copied " + name : "Copied " + plural(s.files, "file") + " to " + name); break;
+                    case FileOps::Op::Move: say((pasting_ ? "Moved " : "Renamed to ") + name); break;
+                    case FileOps::Op::Delete: say(s.files == 1 ? "Deleted " + name : "Deleted " + name + ", " + plural(s.files, "file")); break;
+                    default: say("Made " + name); break;
+                }
+                // The clipboard must not point at what has moved or gone.
+                bool gone = s.op == FileOps::Op::Delete || s.op == FileOps::Op::Move;
+                if (clip_ && gone && files::isInside(clip_.path, s.path)) clip_ = Item();
+            }
+            open(cwd_, selectAfter_);
+            break;
+        }
+        default: break;
+    }
+}
+
+void StorageApp::paste(bool replace) {
+    if (!clip_) return say("Nothing to paste: c copies, x cuts");
+    std::string name = baseName(clip_.path), why;
+    if (cut_) {
+        why = ops_.move(clip_.path, clip_.folder, joinPath(cwd_, name), replace);
+    } else {
+        // A copy next to its original: "a (2).txt", or the next number that's free.
+        if (parentOf(clip_.path) == cwd_)
+            for (int n = 2; n < 100 && list_.find(name) >= 0; n++) name = files::copyName(baseName(clip_.path), n);
+        why = ops_.copy(clip_.path, clip_.folder, cwd_, name, replace);
+    }
+    target_.path = joinPath(cwd_, name);
+    target_.folder = clip_.folder;
+    pasting_ = true;
+    selectIndex_ = rows_.selected();  // where to stay if nothing comes of it
+    work(why, name);
+}
+
+void StorageApp::askDelete(const Item& item, uint32_t count, uint32_t bytes) {
+    std::string name = files::fitName(baseName(item.path), 22);
+    if (!item.folder) question_ = "Delete " + name + " (" + formatBytes(bytes) + ")?";
+    else if (count == 0) question_ = "Delete the empty folder " + name + "?";
+    else question_ = "Delete " + name + " and its " + plural(count, "file") + " (" + formatBytes(bytes) + ")?";
+    question_ += " It can't be undone.";
+    target_ = item;
+    ask_ = Ask::Delete;
+    dialog_.reset(new DialogModel({"Cancel", "Delete"}));
+    requestRedraw();
+}
+
+void StorageApp::onAnswer(int button) {
+    Ask asked = ask_;
+    ask_ = Ask::None;
+    dialog_.reset();
+    if (button != 1) return;
+    switch (asked) {
+        case Ask::Delete:
+            selectIndex_ = rows_.selected();
+            pasting_ = false;
+            work(ops_.remove(target_.path, target_.folder), "");
+            break;
+        case Ask::Replace: paste(true); break;
+        case Ask::Maintenance:
+            view_ = View::Maintenance;
+            maintenance_.enter();
+            break;
+        default: break;
+    }
+}
+
+void StorageApp::showDetails(const Item& item) {
+    int i = rows_.selected();
+    std::string name = baseName(item.path);
+    details_.clear();
+    details_.push_back(name);
+    if (item.folder) details_.push_back("Folder");
+    else {
+        uint32_t size = list_.size(i);
+        std::string text = std::string(kindText(name)) + ", " + formatBytes(size);
+        if (size >= 1024) text += " (" + std::to_string(size) + " bytes)";
+        details_.push_back(text);
+    }
+    details_.push_back("Modified " + files::formatStamp(list_.modified(i)));
+    details_.push_back("In " + cwd_);
+    std::string why = ops_.whyReadOnly(item.path, item.folder);
+    if (!why.empty()) details_.push_back("Read-only: " + why);
+    if (item.folder) {
+        details_.push_back("Counting...");
+        if (ops_.count(item.path).empty()) wait_ = Wait::CountForDetails;
+        else details_.pop_back();
+    }
+    detailsTop_ = 0;
+    view_ = View::Details;
+}
+
+bool StorageApp::onKey(const KeyEvent& e) {
+    requestRedraw();
+    if (view_ == View::NoMemory) return false;
+    if (view_ == View::Maintenance) {
+        if (!maintenance_.onKey(e)) {
+            view_ = View::Browse;
+            open(cwd_);  // a Clean-up may have emptied what was shown
+        }
+        return true;
+    }
+    if (view_ == View::Editor) {
+        if (!noteEditor_.onKey(e)) {
+            std::string name = baseName(noteEditor_.path());
+            noteEditor_.close();
+            view_ = View::Browse;
+            open(cwd_, name);  // its size and date have changed
+        }
+        return true;
+    }
+    if (view_ == View::Viewer && viewer_.showingText() && e.key == Key::Char && (e.ch == 'e' || e.ch == 'E')) {
+        // Edit it (Q146), if the rules and its size allow.
+        std::string path = viewer_.path(), why = ops_.whyReadOnly(path, false);
+        if (why.empty() && viewer_.size() > notes::NoteText::kMaxBytes) why = "Too big to edit: 16 KB at most";
+        if (why.empty()) {
+            viewer_.close();
+            why = noteEditor_.open(path);
+            if (why.empty()) view_ = View::Editor;
+            else {
+                view_ = View::Browse;
+                say(why);
+            }
+        } else {
+            viewer_.say(why);
+        }
+        return true;
+    }
+    if (view_ == View::Viewer) {
+        if (!viewer_.onKey(e)) {
+            viewer_.close();
+            view_ = View::Browse;
+        }
+        return true;
+    }
+    if (dialog_) {
+        dialog_->onKey(e);
+        if (dialog_->result() != DialogModel::kPending) onAnswer(dialog_->result());
+        return true;
+    }
+    if (view_ == View::Details) {
+        if (e.key == Key::Up) detailsTop_ = std::max(0, detailsTop_ - 1);
+        else if (e.key == Key::Down) detailsTop_++;  // clamped when drawn
+        else if (e.key == Key::Back || e.key == Key::Select) {
+            if (wait_ == Wait::CountForDetails) ops_.cancel();
+            view_ = View::Browse;
+        }
+        return true;
+    }
+    // A copy, a delete or a count is running: Back stops it, nothing else gets through. The same
+    // while a folder is being read, which nothing stops.
+    if (wantList_) return true;
+    if (wait_ != Wait::None) {
+        if (e.key == Key::Back && wait_ != Wait::List) ops_.cancel();
+        return true;
+    }
+    if (view_ == View::Name) return onNameKey(e);
+    return onBrowseKey(e);
+}
+
+bool StorageApp::onNameKey(const KeyEvent& e) {
+    switch (e.key) {
+        case Key::Char: editor_.insert(e.ch); break;
+        case Key::Delete: editor_.backspace(); break;
+        case Key::Left: editor_.left(); break;
+        case Key::Right: editor_.right(); break;
+        case Key::Back: view_ = View::Browse; break;
+        case Key::Select: {
+            const std::string& name = editor_.text();
+            std::string why = files::checkName(name);
+            if (!why.empty()) {
+                say(why);
+                break;
+            }
+            pasting_ = false;
+            bool started = true;
+            if (!renaming_) {
+                target_.path = joinPath(cwd_, name);
+                target_.folder = true;
+                started = work(ops_.makeFolder(target_.path), name);
+            } else if (name != baseName(target_.path)) {
+                std::string to = joinPath(cwd_, name);
+                started = work(ops_.move(target_.path, target_.folder, to), name);
+                if (started) target_.path = to;
+            }
+            if (started) view_ = View::Browse;
+            break;
+        }
+        default: break;
+    }
+    return true;
+}
+
+bool StorageApp::onBrowseKey(const KeyEvent& e) {
+    auto askMaintenance = [this]() {
+        question_ = "Clean-up and Erase delete files for good: there is no undo.";
+        ask_ = Ask::Maintenance;
+        dialog_.reset(new DialogModel({"Back", "Go on"}));
+    };
+    if (e.key == Key::Back) {
+        if (cwd_ == "/" || !cardPresent_) return false;  // leaves the App
+        open(parentOf(cwd_), baseName(cwd_));
+        return true;
+    }
+    uint32_t ch = e.key == Key::Char ? (e.ch >= 'A' && e.ch <= 'Z' ? e.ch + 32 : e.ch) : 0;
+    if (ch == 'm') askMaintenance();
+    if (!cardPresent_ || !loaded_) return true;
+
+    Item item = selected();
+    switch (e.key) {
+        case Key::Up: rows_.up(); return true;
+        case Key::Down: rows_.down(); return true;
+        case Key::Left: rows_.pageUp(); return true;
+        case Key::Right: rows_.pageDown(); return true;
+        case Key::Select:
+            if (onMaintenanceRow()) askMaintenance();
+            else if (item && item.folder) open(item.path);
+            else if (item) {
+                viewer_.open(item.path, list_.size(rows_.selected()));
+                view_ = View::Viewer;
+            }
+            return true;
+        case Key::Delete: ch = 'd'; break;
+        default: break;
+    }
+    switch (ch) {
+        case 'v': paste(false); return true;
+        case 'n':
+            renaming_ = false;
+            editor_.setText("");
+            view_ = View::Name;
+            return true;
+        case 's': {
+            sort_ = sort_ == files::FileSort::Name ? files::FileSort::Date : sort_ == files::FileSort::Date ? files::FileSort::Size : files::FileSort::Name;
+            std::string keep = item ? baseName(item.path) : "";
+            bool onLast = onMaintenanceRow();
+            list_.sort(sort_);
+            if (!onLast) rows_.select(std::max(0, list_.find(keep)));
+            say(sort_ == files::FileSort::Name ? "Sorted by name" : sort_ == files::FileSort::Date ? "Sorted by date, newest first" : "Sorted by size, biggest first");
+            return true;
+        }
+        default: break;
+    }
+    if (!item || !(ch == 'c' || ch == 'x' || ch == 'r' || ch == 'd' || ch == 'i')) return true;
+
+    std::string name = files::fitName(baseName(item.path), 18);
+    if (ch == 'i') {
+        showDetails(item);
+        return true;
+    }
+    if (ch == 'c') {
+        clip_ = item;
+        cut_ = false;
+        say("v pastes a copy of " + name);
+        return true;
+    }
+    // Cut, rename and delete change the original: the rules of Q130 first.
+    std::string why = ops_.whyReadOnly(item.path, item.folder);
+    if (!why.empty()) {
+        say(why);
+        return true;
+    }
+    if (ch == 'x') {
+        clip_ = item;
+        cut_ = true;
+        say("v moves " + name + " here");
+    } else if (ch == 'r') {
+        target_ = item;
+        renaming_ = true;
+        editor_.setText(baseName(item.path));
+        view_ = View::Name;
+    } else if (item.folder) {  // 'd': what's inside is counted first (Q132)
+        target_ = item;
+        std::string busy = ops_.count(item.path);
+        if (!busy.empty()) say(busy);
+        else {
+            wait_ = Wait::CountToDelete;
+            waitSinceMs_ = millis();
+        }
+    } else {
+        askDelete(item, 1, list_.size(rows_.selected()));
+    }
+    return true;
+}
+
+void StorageApp::draw(Canvas& c) {
+    lastDrawMs_ = millis();
+    const auto& area = theme::kContent;
+    c.setTextDatum(top_left);
+    switch (view_) {
+        case View::NoMemory:
+            c.setFont(&fonts::bold);
+            c.setTextColor(theme::kWarning);
+            c.drawString("Not enough memory", 4, area.y + 4);
+            c.setFont(&fonts::body);
+            c.setTextColor(theme::kMuted);
+            c.drawString("Close what's running (IRC, a page", 4, area.y + 22);
+            c.drawString("in Gemini) and open Storage again.", 4, area.y + 22 + theme::kLineHeight);
+            return;
+        case View::Maintenance: maintenance_.draw(c); return;
+        case View::Viewer: viewer_.draw(c); return;
+        case View::Editor: noteEditor_.draw(c); return;
+        case View::Details: {
+            std::vector<std::string> lines;
+            auto measure = widgets::bodyMeasure(c);
+            for (auto& d : details_)
+                for (auto& l : wrapText(d, area.w - 12, measure)) lines.push_back(l);
+            int rows = (area.h - 2) / theme::kLineHeight;
+            detailsTop_ = std::clamp(detailsTop_, 0, std::max(0, static_cast<int>(lines.size()) - rows));
+            widgets::textLines(c, lines, detailsTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 2});
+            return;
+        }
+        default: break;
+    }
+    drawBrowse(c);
+    if (view_ == View::Name) {
+        theme::Rect box{16, 44, theme::kWidth - 32, 48};
+        c.fillRect(box.x, box.y, box.w, box.h, theme::kBackground);
+        c.drawRect(box.x, box.y, box.w, box.h, theme::kAccent);
+        c.setFont(&fonts::bold);
+        c.setTextColor(theme::kText);
+        c.drawString(renaming_ ? "Rename" : "New folder", box.x + 6, box.y + 4);
+        widgets::lineEditor(c, editor_, {box.x + 6, box.y + 22, box.w - 12, theme::kLineHeight + 4});
+    }
+    if (dialog_) {
+        const char* title = ask_ == Ask::Delete ? "Delete" : ask_ == Ask::Replace ? "Replace" : "Maintenance";
+        widgets::dialog(c, title, question_, *dialog_);
+    } else if ((wait_ == Wait::Work || wait_ == Wait::CountToDelete) && millis() - waitSinceMs_ >= kQuietMs) {
+        drawProgress(c);
+    }
+}
+
+void StorageApp::drawBrowse(Canvas& c) {
+    const auto& area = theme::kContent;
+    StorageState card = storage_.state();
+
+    // Where we are, and how much room is left (Q129).
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    std::string right;
+    if (card.present) {
+        right = formatBytes(card.totalBytes - card.usedBytes) + " free";
+        if (loaded_ && list_.more() > 0) right = "first " + std::to_string(list_.count()) + " of " + std::to_string(list_.count() + list_.more());
+    }
+    size_t room = static_cast<size_t>((area.w - 12) / 5) - right.size() - 1;
+    std::string path = cwd_.size() <= room ? cwd_ : ".." + cwd_.substr(cwd_.size() - (room - 2));
+    c.drawString(path.c_str(), 4, area.y + 1);
+    c.setTextDatum(top_right);
+    c.drawString(right.c_str(), area.w - 3, area.y + 1);
+    c.setTextDatum(top_left);
+
+    theme::Rect rows{area.x, area.y + 10, area.w, kRows * theme::kLineHeight};
+    c.setFont(&fonts::body);
+    if (!card.present) {
+        c.setTextColor(theme::kWarning);
+        c.drawString("No SD card", 4, rows.y + 4);
+    } else if (!loaded_) {
+        // Nothing yet: the footer says what's being read.
+    } else if (rows_.count() == 0) {
+        c.setTextColor(theme::kMuted);
+        c.drawString("Nothing in this folder.", 4, rows.y + 4);
+        c.drawString("n makes a folder, v pastes.", 4, rows.y + 4 + theme::kLineHeight);
+    } else {
+        int entries = static_cast<int>(list_.count());
+        auto value = [&](int i) {
+            return i >= entries ? std::string(">") : files::rowDetail(list_.folder(i), list_.size(i), list_.modified(i));
+        };
+        widgets::list(
+            c, rows_, rows,
+            [&](int i) {
+                if (i >= entries) return std::string("Maintenance");
+                size_t fits = static_cast<size_t>((area.w - 22) / 6) - value(i).size();
+                return files::fitName(list_.name(i), fits);
+            },
+            value);
+    }
+
+    // Footer: a message for a few seconds, what v would paste, or the keys.
+    c.setFont(&fonts::small);
+    bool showMessage = !message_.empty() && millis() - messageMs_ < kMessageMs;
+    c.setTextColor(showMessage ? theme::kWarning : theme::kMuted);
+    std::string keys = "c x v:paste r:name d:del n:new i:info s:sort";
+    if ((wantList_ || wait_ == Wait::List) && millis() - waitSinceMs_ >= kQuietMs) keys = "Reading " + files::fitName(want_, 30) + "...";
+    else if (clip_) keys = std::string("v: ") + (cut_ ? "move " : "copy ") + files::fitName(baseName(clip_.path), 20) + " here";
+    c.drawString(showMessage ? message_.c_str() : keys.c_str(), 4, area.y + area.h - 9);
+}
+
+void StorageApp::drawProgress(Canvas& c) {
+    FileOps::Status s = ops_.status();
+    theme::Rect box{20, 40, theme::kWidth - 40, 58};
+    c.fillRect(box.x, box.y, box.w, box.h, theme::kBackground);
+    c.drawRect(box.x, box.y, box.w, box.h, theme::kAccent);
+    c.setTextDatum(top_left);
+    c.setFont(&fonts::bold);
+    c.setTextColor(theme::kText);
+    const char* verb = s.op == FileOps::Op::Copy ? "Copying " : s.op == FileOps::Op::Delete ? "Deleting " : s.op == FileOps::Op::Count ? "Counting " : "Moving ";
+    c.drawString((verb + files::fitName(baseName(target_.path), 20)).c_str(), box.x + 6, box.y + 4);
+
+    c.setFont(&fonts::body);
+    c.setTextColor(theme::kMuted);
+    std::string line = plural(s.files, "file");
+    if (s.op == FileOps::Op::Copy && s.totalBytes > 0) {
+        int w = box.w - 12, done = static_cast<int>(static_cast<uint64_t>(s.doneBytes) * w / s.totalBytes);
+        c.drawRect(box.x + 6, box.y + 21, w, 7, theme::kMuted);
+        c.fillRect(box.x + 6, box.y + 21, std::min(done, w), 7, theme::kAccent);
+        line = formatBytes(s.doneBytes) + " of " + formatBytes(s.totalBytes);
+    }
+    c.drawString(line.c_str(), box.x + 6, box.y + 31);
+    c.setFont(&fonts::small);
+    c.drawString("Back: cancel", box.x + 6, box.y + box.h - 10);
+}
+
+}  // namespace roro
@@ -0,0 +1,98 @@
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "app.h"
+#include "apps/file_viewer.h"
+#include "apps/maintenance_page.h"
+#include "apps/note_editor.h"
+#include "dialog_model.h"
+#include "event_bus.h"
+#include "file_list.h"
+#include "line_editor.h"
+#include "list_model.h"
+#include "services/clock_service.h"
+#include "services/file_ops.h"
+#include "services/storage_service.h"
+#include "ui/theme.h"
+
+namespace roro {
+
+// The Storage App (docs/milestones/F1.md): the SD card's folders and files, one item at a time
+// with a clipboard (Q131). Enter opens a folder, or a file in its viewer (Q134); Back goes up;
+// c copy, x cut, v paste here, r rename, d delete, n new folder, i details, s sort. At the top of the card, the last row is Maintenance:
+// usage, Storage Clean-up and erasing the card, behind a warning (Q128).
+class StorageApp : public App {
+   public:
+    StorageApp(FileOps& ops, StorageService& storage, ClockService& clock, UpdateService& update, PowerService& power, EventBus& bus)
+        : ops_(ops), storage_(storage), bus_(bus), maintenance_(storage, clock, bus), viewer_(storage, update), noteEditor_(storage, clock, power) {}
+    void onEnter() override;
+    void onExit() override;
+    bool onKey(const KeyEvent& e) override;
+    bool textEntryActive() const override { return view_ == View::Name || view_ == View::Editor; }
+    void update(uint32_t nowMs) override;
+    void draw(Canvas& c) override;
+
+   private:
+    enum class View { Browse, Details, Name, Viewer, Editor, Maintenance, NoMemory };
+    enum class Ask { None, Delete, Replace, Maintenance };
+    enum class Wait { None, List, CountToDelete, CountForDetails, Work };  // what the running operation is for
+    static constexpr int kRows = 8;
+    static constexpr size_t kStartFloor = 55 * 1024;  // Q86, Q136
+
+    struct Item {
+        std::string path;
+        bool folder = false;
+        explicit operator bool() const { return !path.empty(); }
+    };
+
+    void open(const std::string& folder, const std::string& select = "");
+    void onFinished(const FileOps::Status& s);
+    bool onBrowseKey(const KeyEvent& e);
+    bool onNameKey(const KeyEvent& e);
+    void onAnswer(int button);
+    Item selected() const;  // empty on the Maintenance row or in an empty folder
+    bool onMaintenanceRow() const { return cwd_ == "/" && rows_.selected() == static_cast<int>(list_.count()); }
+    void paste(bool replace);
+    void askDelete(const Item& item, uint32_t files, uint32_t bytes);
+    void showDetails(const Item& item);
+    bool work(const std::string& why, const std::string& selectAfter);  // an operation was asked for: did it start?
+    void say(const std::string& text);
+    void drawBrowse(Canvas& c);
+    void drawProgress(Canvas& c);
+
+    FileOps& ops_;
+    StorageService& storage_;
+    EventBus& bus_;
+    MaintenancePage maintenance_;
+    FileViewer viewer_;
+    NoteEditor noteEditor_;  // `e` in the text viewer (Q146)
+
+    View view_ = View::Browse;
+    std::string cwd_ = "/", want_ = "/";  // the folder on screen; the one being read
+    files::FileList list_;
+    files::FileSort sort_ = files::FileSort::Name;
+    ListModel rows_{kRows};
+    bool wantList_ = false, loaded_ = false, cardPresent_ = false;
+    std::string selectAfter_;  // after the next listing: the name to select, or else the row
+    int selectIndex_ = 0;
+
+    Wait wait_ = Wait::None;
+    uint32_t waitSinceMs_ = 0, lastDrawMs_ = 0;
+    Item clip_, target_;  // the clipboard; what a dialog, the editor or the details are about
+    bool cut_ = false;
+    Ask ask_ = Ask::None;
+    std::unique_ptr<DialogModel> dialog_;
+    std::string question_;
+    LineEditor editor_{60};
+    bool renaming_ = false;  // Name view: renaming target_, or else a new folder
+    bool pasting_ = false;   // the operation running came from v: it may ask to replace
+    std::vector<std::string> details_;
+    int detailsTop_ = 0;
+    std::string message_;
+    uint32_t messageMs_ = 0;
+};
+
+}  // namespace roro
@@ -0,0 +1,361 @@
+#include "system_app.h"
+
+#include <Arduino.h>
+#include <SD.h>
+#include <esp_heap_caps.h>
+
+#include <algorithm>
+#include <cstdio>
+
+#include "cleanup_plan.h"
+#include "platform/system_info.h"
+#include "sd_fault.h"
+#include "services/gemini_service.h"
+#include "ui/canvas.h"
+#include "ui/fonts.h"
+#include "ui/theme.h"
+#include "ui/widgets.h"
+
+namespace roro {
+
+namespace {
+
+constexpr size_t kUsers = static_cast<size_t>(net::User::Count);
+
+// Collects what the console's `info` prints, so the System view can't drift from it (Q125).
+class Lines : public Print {
+   public:
+    size_t write(uint8_t ch) override {
+        if (ch == '\n') {
+            lines.push_back(current_);
+            current_.clear();
+        } else if (ch != '\r') {
+            current_ += static_cast<char>(ch);
+        }
+        return 1;
+    }
+    std::vector<std::string> lines;
+
+   private:
+    std::string current_;
+};
+
+std::string duration(uint32_t seconds) {
+    char s[24];
+    if (seconds < 3600) std::snprintf(s, sizeof s, "%lu min %02lu s", (unsigned long)(seconds / 60), (unsigned long)(seconds % 60));
+    else std::snprintf(s, sizeof s, "%lu h %02lu min", (unsigned long)(seconds / 3600), (unsigned long)(seconds / 60 % 60));
+    return s;
+}
+
+// A filled bar for a percentage; the warning colour from 90 %.
+void bar(Canvas& c, int x, int y, int w, int percent) {
+    c.drawRect(x, y, w, 9, theme::kMuted);
+    int filled = std::clamp(percent, 0, 100) * (w - 2) / 100;
+    if (filled > 0) c.fillRect(x + 1, y + 1, filled, 7, percent >= 90 ? theme::kWarning : theme::kAccent);
+}
+
+}  // namespace
+
+void SystemApp::onEnter() {
+    view_ = View::Overview;
+    beforeTotal_ = system_info::sampleTasks(before_);
+    sampledMs_ = millis();
+    for (size_t i = 0; i < kUsers; i++) traffic_[i] = net::traffic(static_cast<net::User>(i));
+    requestRedraw();
+}
+
+void SystemApp::onExit() {  // nothing is kept while it's closed (Q120)
+    std::vector<TaskSample>().swap(before_);
+    std::vector<TaskRow>().swap(rows_);
+    std::vector<std::string>().swap(systemLines_);
+    for (auto& h : loadHistory_) h.clear();
+    heapHistory_.clear();
+    load_[0] = load_[1] = -1;
+}
+
+bool SystemApp::onKey(const KeyEvent& e) {
+    if (e.key == Key::Tab) {
+        int n = static_cast<int>(View::Count), v = static_cast<int>(view_);
+        view_ = static_cast<View>(e.shift ? (v + n - 1) % n : (v + 1) % n);
+        taskTop_ = systemTop_ = 0;
+        requestRedraw();
+        return true;
+    }
+    int step = e.key == Key::Up ? -1 : e.key == Key::Down ? 1 : 0;
+    if (step && view_ == View::Tasks) {
+        taskTop_ = std::clamp(taskTop_ + step, 0, std::max(0, static_cast<int>(rows_.size()) - kTaskRows));
+        requestRedraw();
+        return true;
+    }
+    if (step && view_ == View::System) {
+        systemTop_ = std::clamp(systemTop_ + step, 0, std::max(0, wrappedLines_ - 8));
+        requestRedraw();
+        return true;
+    }
+    if (view_ == View::Tasks && e.key == Key::Char && (e.ch == 's' || e.ch == 'S')) {  // Q122
+        sort_ = static_cast<TaskSort>((static_cast<int>(sort_) + 1) % 3);
+        sortTasks(rows_, sort_);
+        taskTop_ = 0;
+        requestRedraw();
+        return true;
+    }
+    return false;  // Back leaves the App
+}
+
+void SystemApp::update(uint32_t nowMs) {
+    if (nowMs - sampledMs_ >= 1000) sample(nowMs);
+}
+
+// Once a second (Q119): the tasks' shares over that second, the cores' load, the heap, the traffic.
+void SystemApp::sample(uint32_t nowMs) {
+    uint32_t elapsedMs = nowMs - sampledMs_;
+    sampledMs_ = nowMs;
+
+    std::vector<TaskSample> now;
+    uint32_t total = system_info::sampleTasks(now);
+    rows_ = taskRows(before_, beforeTotal_, now, total);
+    sortTasks(rows_, sort_);
+    before_.swap(now);
+    beforeTotal_ = total;
+    for (int core = 0; core < 2; core++) {
+        load_[core] = coreLoad(rows_, core);
+        loadHistory_[core].push(static_cast<uint8_t>(std::max(0, load_[core])));
+    }
+    heapHistory_.push(static_cast<uint16_t>(ESP.getFreeHeap() / 1024));
+
+    for (size_t i = 0; i < kUsers; i++) {
+        net::Traffic t = net::traffic(static_cast<net::User>(i));
+        rateIn_[i] = net::bytesPerSecond(traffic_[i].in, t.in, elapsedMs);
+        rateOut_[i] = net::bytesPerSecond(traffic_[i].out, t.out, elapsedMs);
+        traffic_[i] = t;
+    }
+
+    if (view_ == View::System) {  // the slow things: only while they're on screen
+        Lines out;
+        system_info::printSystem(out);
+        const BatteryEstimator& b = battery_.estimator();
+        if (b.hasReading()) out.printf("battery: %d %%, %d.%02d V\n", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
+        StorageState card = storage_.state();
+        if (card.present)
+            out.printf("sd: %s of %s used, %u write faults\n", formatBytes(card.usedBytes).c_str(), formatBytes(card.totalBytes).c_str(),
+                       (unsigned)sdLastFault().count);
+        else out.println("sd: no card");
+        out.printf("radio: %s\n", !radio_.present() ? "none" : radio_.sweeping() ? "sweeping" : radio_.listening() ? "listening" : "asleep");
+        const auto& g = gnss_.state();
+        out.printf("gnss: %s, %d satellites used\n", !gnss_.on() ? "off" : gnss_.receiving(nowMs) ? "receiving" : "silent", g.satellitesUsed);
+        system_info::printSlots(out, store_);
+        systemLines_.swap(out.lines);
+    }
+    requestRedraw();
+}
+
+void SystemApp::footer(Canvas& c, const char* keys) {
+    const auto& area = theme::kContent;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.setTextDatum(top_left);
+    c.drawString(keys, 4, area.y + area.h - 9);
+}
+
+void SystemApp::draw(Canvas& c) {
+    c.setTextDatum(top_left);
+    switch (view_) {
+        case View::Overview: drawOverview(c); break;
+        case View::Tasks: drawTasks(c); break;
+        case View::Memory: drawMemory(c); break;
+        case View::Network: drawNetwork(c); break;
+        case View::System: drawSystem(c); break;
+        default: break;
+    }
+}
+
+void SystemApp::drawOverview(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    int y = area.y + 2;
+    for (int core = 0; core < 2; core++) {
+        c.setTextColor(theme::kMuted);
+        std::snprintf(line, sizeof line, "Core %d", core);
+        c.drawString(line, 4, y);
+        bar(c, 52, y + 2, 130, load_[core]);
+        c.setTextColor(theme::kText);
+        if (load_[core] >= 0) std::snprintf(line, sizeof line, "%d%%", load_[core]);
+        else std::snprintf(line, sizeof line, "...");
+        c.drawString(line, 190, y);
+        y += theme::kLineHeight;
+    }
+    auto row = [&](const char* label, const std::string& value) {
+        c.setTextColor(theme::kMuted);
+        c.drawString(label, 4, y);
+        c.setTextColor(theme::kText);
+        c.drawString(value.c_str(), 62, y);
+        y += theme::kLineHeight;
+    };
+    std::snprintf(line, sizeof line, "%u KB free, lowest %u", (unsigned)(ESP.getFreeHeap() / 1024), (unsigned)(ESP.getMinFreeHeap() / 1024));
+    row("Memory", line);
+    uint32_t in = 0, out = 0;
+    for (size_t i = 0; i < kUsers; i++) in += rateIn_[i], out += rateOut_[i];
+    if (wifi_.state() == WifiController::State::Connected)
+        std::snprintf(line, sizeof line, "%s/s in, %s/s out", net::formatTraffic(in).c_str(), net::formatTraffic(out).c_str());
+    else std::snprintf(line, sizeof line, "not connected");
+    row("Network", line);
+    const BatteryEstimator& b = battery_.estimator();
+    if (b.hasReading()) std::snprintf(line, sizeof line, "%d%%, %d.%02d V", b.percent(), b.millivolts() / 1000, b.millivolts() % 1000 / 10);
+    else std::snprintf(line, sizeof line, "...");
+    row("Battery", line);
+    std::snprintf(line, sizeof line, "%s, %.0f C", duration(millis() / 1000).c_str(), temperatureRead());
+    row("Uptime", line);
+
+    // Both cores over the last two minutes: core 0 in the accent colour, core 1 in green.
+    int gx = 4, gy = y + 3, gw = static_cast<int>(kHistory) * 2 - 8, gh = area.y + area.h - 12 - gy;
+    if (gh > 8) {
+        c.drawRect(gx, gy, gw + 2, gh + 2, theme::kMuted);
+        for (int core = 0; core < 2; core++) {
+            const auto& h = loadHistory_[core];
+            for (size_t i = 1; i < h.size(); i++) {
+                int x0 = gx + 1 + static_cast<int>((i - 1) * gw / kHistory), x1 = gx + 1 + static_cast<int>(i * gw / kHistory);
+                c.drawLine(x0, gy + gh - h.at(i - 1) * gh / 100, x1, gy + gh - h.at(i) * gh / 100, core ? theme::kMessage : theme::kAccent);
+            }
+        }
+    }
+    footer(c, "Tab: tasks, memory, network, system");
+}
+
+void SystemApp::drawTasks(Canvas& c) {
+    const auto& area = theme::kContent;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString("task", 4, area.y + 2);
+    c.setTextDatum(top_right);
+    c.drawString("core", 128, area.y + 2);
+    c.drawString("cpu", 176, area.y + 2);
+    c.drawString("stack left", area.w - 4, area.y + 2);
+    c.setFont(&fonts::body);
+    char cell[16];
+    for (int i = 0; i < kTaskRows && taskTop_ + i < static_cast<int>(rows_.size()); i++) {
+        const TaskRow& r = rows_[taskTop_ + i];
+        int y = area.y + 12 + i * theme::kLineHeight;
+        c.setTextDatum(top_left);
+        c.setTextColor(r.idle ? theme::kMuted : theme::kText);
+        c.drawString(r.name.c_str(), 4, y);
+        c.setTextDatum(top_right);
+        c.setTextColor(theme::kMuted);
+        c.drawString(r.core < 0 ? "any" : std::to_string(r.core).c_str(), 128, y);
+        c.setTextColor(r.idle ? theme::kMuted : theme::kText);
+        std::snprintf(cell, sizeof cell, "%u.%u%%", r.permille / 10, r.permille % 10);
+        c.drawString(cell, 176, y);
+        c.setTextColor(r.lowStack ? theme::kWarning : theme::kMuted);  // Q122: under 512 bytes
+        c.drawString(std::to_string(r.stackFree).c_str(), area.w - 4, y);
+    }
+    c.setTextDatum(top_left);
+    std::string keys = std::string("s: by ") + (sort_ == TaskSort::Share ? "stack" : sort_ == TaskSort::Stack ? "name" : "cpu") +
+                       "   " + std::to_string(rows_.size()) + " tasks   Tab: memory";
+    footer(c, keys.c_str());
+}
+
+void SystemApp::drawMemory(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    c.setTextColor(theme::kText);
+    std::snprintf(line, sizeof line, "%.1f KB free, lowest %.1f", ESP.getFreeHeap() / 1024.0, ESP.getMinFreeHeap() / 1024.0);
+    c.drawString(line, 4, area.y + 2);
+    c.setTextColor(theme::kMuted);
+    std::snprintf(line, sizeof line, "largest free block %.1f KB", heap_caps_get_largest_free_block(MALLOC_CAP_8BIT) / 1024.0);
+    c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
+
+    // Free heap over two minutes, with the floors of Q86 as lines.
+    int gx = 26, gy = area.y + 32, gw = area.w - gx - 6, gh = area.y + area.h - 12 - gy;
+    uint16_t top = 128;  // KB at the top of the scale: more if the heap has been higher
+    for (size_t i = 0; i < heapHistory_.size(); i++) top = std::max<uint16_t>(top, heapHistory_.at(i) + 8);
+    auto yOf = [&](int kb) { return gy + gh - std::clamp(kb, 0, static_cast<int>(top)) * gh / top; };
+    c.drawRect(gx, gy, gw, gh + 1, theme::kMuted);
+    c.setFont(&fonts::small);
+    struct {
+        size_t bytes;
+        uint16_t color;
+    } floors[] = {{GeminiService::kStartFloor, theme::kMuted}, {GeminiService::kSteadyFloor, theme::kWarning}, {GeminiService::kTransientFloor, theme::kMessage}};
+    for (auto& f : floors) {
+        int kb = static_cast<int>(f.bytes / 1024), y = yOf(kb);
+        for (int x = gx + 1; x < gx + gw - 1; x += 4) c.drawPixel(x, y, f.color);
+        c.setTextColor(f.color);
+        c.setTextDatum(top_right);
+        c.drawString(std::to_string(kb).c_str(), gx - 3, y - 3);
+    }
+    c.setTextDatum(top_left);
+    for (size_t i = 1; i < heapHistory_.size(); i++) {
+        int x0 = gx + 1 + static_cast<int>((i - 1) * (gw - 2) / kHistory), x1 = gx + 1 + static_cast<int>(i * (gw - 2) / kHistory);
+        c.drawLine(x0, yOf(heapHistory_.at(i - 1)), x1, yOf(heapHistory_.at(i)), theme::kAccent);
+    }
+    footer(c, "KB free, 2 min, with the floors   Tab: network");
+}
+
+void SystemApp::drawNetwork(Canvas& c) {
+    const auto& area = theme::kContent;
+    char line[72];
+    c.setFont(&fonts::body);
+    WifiService::Connection n = wifi_.connection();
+    c.setTextColor(n.connected ? theme::kText : theme::kWarning);
+    if (n.connected) std::snprintf(line, sizeof line, "%s, %d dBm", wifi_.ssid().c_str(), wifi_.rssi());
+    else std::snprintf(line, sizeof line, "Wi-Fi isn't connected");
+    c.drawString(line, 4, area.y + 2);
+    if (n.connected) {
+        c.setTextColor(theme::kMuted);
+        std::snprintf(line, sizeof line, "%s/%d %s, gw %s", n.address.c_str(), n.prefix, n.fixed ? "fixed" : "DHCP",
+                      n.gateway.empty() ? "none" : n.gateway.c_str());
+        c.drawString(line, 4, area.y + 2 + theme::kLineHeight);
+    }
+    // Per service (Q121): totals since boot, and the last second.
+    int y = area.y + 32;
+    c.setFont(&fonts::small);
+    c.setTextColor(theme::kMuted);
+    c.drawString("service", 4, y);
+    c.setTextDatum(top_right);
+    c.drawString("in", 124, y);
+    c.drawString("out", 168, y);
+    c.drawString("now, /s", area.w - 4, y);
+    c.setFont(&fonts::body);
+    y += 10;
+    for (size_t i = 0; i < kUsers; i++) {
+        bool active = rateIn_[i] || rateOut_[i];
+        c.setTextDatum(top_left);
+        c.setTextColor(active ? theme::kMessage : theme::kText);
+        c.drawString(net::userName(static_cast<net::User>(i)), 4, y);
+        c.setTextDatum(top_right);
+        c.setTextColor(theme::kText);
+        c.drawString(net::formatTraffic(traffic_[i].in).c_str(), 124, y);
+        c.drawString(net::formatTraffic(traffic_[i].out).c_str(), 168, y);
+        c.setTextColor(active ? theme::kMessage : theme::kMuted);
+        c.drawString(active ? net::formatTraffic(rateIn_[i] + rateOut_[i]).c_str() : "-", area.w - 4, y);
+        y += theme::kLineHeight;
+    }
+    c.setTextDatum(top_left);
+    footer(c, "bytes since boot   Tab: system");
+}
+
+void SystemApp::drawSystem(Canvas& c) {
+    const auto& area = theme::kContent;
+    if (systemLines_.empty()) {
+        c.setFont(&fonts::body);
+        c.setTextColor(theme::kMuted);
+        c.drawString("Reading...", 4, area.y + 4);
+        return;
+    }
+    // The console's lines are longer than the screen: wrap them, continuation lines indented.
+    std::vector<std::string> wrapped;
+    auto measure = widgets::bodyMeasure(c);
+    for (const std::string& line : systemLines_) {
+        bool first = true;
+        for (const std::string& part : wrapText(line, area.w - 14, measure)) {
+            wrapped.push_back(first ? part : "  " + part);
+            first = false;
+        }
+    }
+    wrappedLines_ = static_cast<int>(wrapped.size());
+    systemTop_ = std::clamp(systemTop_, 0, std::max(0, wrappedLines_ - 8));
+    widgets::textLines(c, wrapped, systemTop_, {area.x + 2, area.y + 2, area.w - 2, area.h - 12});
+    footer(c, "Tab: overview");
+}
+
+}  // namespace roro
@@ -0,0 +1,67 @@
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include "app.h"
+#include "key_value_store.h"
+#include "services/battery_service.h"
+#include "services/gnss_service.h"
+#include "services/radio_service.h"
+#include "services/storage_service.h"
+#include "services/wifi_service.h"
+#include "task_stats.h"
+#include "traffic.h"
+
+namespace roro {
+
+// The System App (docs/milestones/S1.md, Q117 to Q127): what the device is doing, live and
+// read-only. Tab moves between Overview, Tasks, Memory, Network and System. It samples once a
+// second and keeps two minutes of history, only while it's open (Q120).
+class SystemApp : public App {
+   public:
+    SystemApp(WifiService& wifi, BatteryService& battery, StorageService& storage, RadioService& radio, GnssService& gnss,
+              KeyValueStore& store)
+        : wifi_(wifi), battery_(battery), storage_(storage), radio_(radio), gnss_(gnss), store_(store) {}
+    void onEnter() override;
+    void onExit() override;
+    bool onKey(const KeyEvent& e) override;
+    void update(uint32_t nowMs) override;
+    void draw(Canvas& c) override;
+
+   private:
+    enum class View : uint8_t { Overview, Tasks, Memory, Network, System, Count };
+    static constexpr size_t kHistory = 120;  // seconds
+    static constexpr int kTaskRows = 7;
+
+    void sample(uint32_t nowMs);
+    void drawOverview(Canvas& c);
+    void drawTasks(Canvas& c);
+    void drawMemory(Canvas& c);
+    void drawNetwork(Canvas& c);
+    void drawSystem(Canvas& c);
+    void footer(Canvas& c, const char* keys);
+
+    WifiService& wifi_;
+    BatteryService& battery_;
+    StorageService& storage_;
+    RadioService& radio_;
+    GnssService& gnss_;
+    KeyValueStore& store_;
+    View view_ = View::Overview;
+    uint32_t sampledMs_ = 0;
+    std::vector<TaskSample> before_;
+    uint32_t beforeTotal_ = 0;
+    std::vector<TaskRow> rows_;  // the last second, sorted
+    TaskSort sort_ = TaskSort::Share;
+    int taskTop_ = 0;
+    int load_[2] = {-1, -1};
+    History<uint8_t, kHistory> loadHistory_[2];
+    History<uint16_t, kHistory> heapHistory_;  // free heap, KB
+    net::Traffic traffic_[static_cast<size_t>(net::User::Count)];
+    uint32_t rateIn_[static_cast<size_t>(net::User::Count)] = {}, rateOut_[static_cast<size_t>(net::User::Count)] = {};
+    std::vector<std::string> systemLines_;
+    int systemTop_ = 0, wrappedLines_ = 0;
+};
+
+}  // namespace roro
@@ -13,12 +13,16 @@
 #include "apps/irc_app.h"
 #include "apps/launcher_app.h"
 #include "apps/lora_scanner_app.h"
+#include "apps/notes_app.h"
 #include "apps/settings_app.h"
+#include "apps/storage_app.h"
+#include "apps/system_app.h"
 #include "apps/wifi_tools_app.h"
 #include "apps/setup_app.h"
 #include "event_bus.h"
 #include "file_receiver.h"
 #include "ipv4.h"
+#include "traffic.h"
 #include "key_mapper.h"
 #include "platform/console.h"
 #include "platform/crash_report.h"
@@ -28,14 +32,18 @@
 #include "sd_fault.h"
 #include "service_manager.h"
 #include "platform/identity.h"
+#include "file_names.h"
 #include "services/battery_service.h"
 #include "services/irc_service.h"
 #include "services/clock_service.h"
 #include "services/debug_console.h"
+#include "services/file_ops.h"
+#include "update_check.h"
 #include "services/gemini_service.h"
 #include "services/gnss_service.h"
 #include "services/power_service.h"
 #include "services/lora_capture_service.h"
+#include "services/noise_test.h"
 #include "services/radio_service.h"
 #include "services/storage_service.h"
 #include "services/update_service.h"
@@ -59,11 +67,16 @@ static Screen screen;
 // Constructed in setup(), after the hardware and Settings are ready.
 static BatteryService* battery;
 static StorageService* storageService;
+static FileOps* fileOps;
+static std::vector<std::string> filesInUse(const std::string& path, bool folder);
 static PowerService* power;
 static ClockService* clockService;
 static GnssService* gnssService;
 static RadioService* radioService;
 static LoraCaptureService* loraCapture;
+#ifdef RORO_DEBUG
+static NoiseTest* noiseTest;
+#endif
 static GeminiService* geminiService;
 static SavedNetworks* savedNetworks;
 static WifiService* wifi;
@@ -169,6 +182,9 @@ void setup() {
    savedNetworks->load();
    wifi = new WifiService(settings, *savedNetworks, *clockService);
    update = new UpdateService(nvs, *wifi, *savedNetworks, *storageService, bus, settings);
+    fileOps = new FileOps(*storageService, filesInUse);
+    update->enableDailyCheck();
+    update->holdMemory = [](bool hold) { irc->holdForUpdate(hold); };  // see UpdateService::holdMemory
    irc = new IrcService(nvs, "roro_" + identity::defaultShortName(), *wifi, *storageService, *clockService, bus);
    notifier = new Notifier(bus, settings);
    notifier->onShow = [](uint32_t now, uint32_t until) { power->onNotification(now, until); };
@@ -178,6 +194,9 @@ void setup() {
    services.add(*gnssService);
    services.add(*radioService);
    loraCapture = new LoraCaptureService(*radioService, *storageService, *clockService, bus);
+#ifdef RORO_DEBUG
+    noiseTest = new NoiseTest(*radioService);
+#endif
    services.add(*loraCapture);
    services.add(*storageService);
    services.add(*wifi);
@@ -195,6 +214,12 @@ void setup() {
    apps->registerApp({"gnss", "GNSS", false, new GnssApp(*gnssService, settings)});
    apps->registerApp({"gemini", "Gemini", false, new GeminiApp(*geminiService)});
    apps->registerApp({"lora", "LoRa Scanner", false, new LoraScannerApp(*radioService, *loraCapture, settings, *clockService)});
+    apps->registerApp({"storage", "Storage", false, new StorageApp(*fileOps, *storageService, *clockService, *update, *power, bus)});
+    apps->registerApp({"notes", "Notes", false, new NotesApp(*fileOps, *storageService, *clockService, *power)});
+    // Leaving the foreground App makes it save: a note being typed, when the device is powered off.
+    power->beforePowerOff = []() { apps->home(); };
+    apps->registerApp({"system", "System", false,
+                       new SystemApp(*wifi, *battery, *storageService, *radioService, *gnssService, nvs)});
    apps->registerApp({"settings", "Settings", false,
                       new SettingsApp({settings, bus, *apps, *battery, *storageService, *clockService, *wifi, *savedNetworks, *update})});
    apps->registerApp({"demo", "Widget demo", true, new DemoApp(bus)});
@@ -381,16 +406,178 @@ static void ipTrialStep() {
 }
 #endif

+// `tasks`: the first sample, and when to take the second and print.
+static std::vector<TaskSample> tasksBefore;
+static uint32_t tasksTotal = 0, tasksDueMs = 0;
+static bool tasksPending = false;
+
+// What the firmware is writing right now: the Storage App and the console leave those alone (Q130).
+static std::vector<std::string> filesInUse(const std::string& path, bool folder) {
+    std::vector<std::string> open;
+    if (gnssService->tracking()) open.push_back(gnssService->trackPath());
+    if (loraCapture->capturing()) open.push_back(loraCapture->path());
+    if (upload.active()) open.push_back(upload.partPath());
+    if (irc->running() && path != "/irc" && files::isInside(path, "/irc")) {
+        // Today's Logs, and any folder that may hold one: the IRC Service appends whenever a line comes.
+        std::string date = clockService->localDate();
+        std::string today = (date.empty() ? "undated" : date) + ".log";
+        if (folder) open.push_back(files::joinPath(path, today));
+        else if (files::baseName(path) == today) open.push_back(path);
+    }
+    return open;
+}
+
+// `cp`, `mv`, `rm`, `mkdir`, `du` run as the Storage App's operations do; the result prints here.
+static bool consoleFileOp = false;
+
+static void fileOpsStep() {
+    FileOps::Status s;
+    if (!consoleFileOp || !fileOps->finished(s)) return;
+    consoleFileOp = false;
+    static const char* const kNames[] = {"", "ls", "du", "cp", "mv", "rm", "mkdir"};
+    const char* name = kNames[static_cast<int>(s.op)];
+    if (!s.error.empty()) console.printf("%s: error %s\n", name, s.error.c_str());
+    else if (s.cancelled) console.printf("%s: cancelled\n", name);
+    else if (s.op == FileOps::Op::Count) console.printf("du: %s, %u files, %u bytes\n", s.path.c_str(), (unsigned)s.files, (unsigned)s.bytes);
+    else if (s.op == FileOps::Op::Copy) console.printf("cp: ok %u files, %u bytes in %.1f s\n", (unsigned)s.files, (unsigned)s.doneBytes, s.ms / 1000.0);
+    else if (s.op == FileOps::Op::Delete) console.printf("rm: ok %u files in %.1f s\n", (unsigned)s.files, s.ms / 1000.0);
+    else console.printf("%s: ok\n", name);
+}
+
+// `update ...`: the project's releases on Gitea (R1, #6). The answers come from the Update Service's
+// task a moment later; updateStep() prints them.
+static int updateWatch = 0;  // 1: a check, 2: a list
+
+static void printReleases(bool list) {
+    GiteaReleases& g = update->gitea();
+    if (g.status() == GiteaReleases::Status::Failed) return (void)console.printf("update: %s\n", g.error().c_str());
+    std::string running = update->runningVersion();
+    if (!list) {
+        release::Release r;
+        if (!g.latest(r)) return (void)console.println("update: nothing known yet");
+        console.printf("update: latest %s of %s, %u bytes: %s (running %s)\n", r.tag.c_str(), r.date().c_str(), (unsigned)r.otaSize,
+                       release::isNewer(r, running) ? "newer" : "not newer", running.c_str());
+        console.printf("update: %s\n", r.notes.c_str());
+        return;
+    }
+    for (auto& r : g.list())
+        console.printf("update: %-8s %s %8u B  %s\n", r.tag.c_str(), r.date().c_str(), (unsigned)r.otaSize, r.notes.substr(0, 60).c_str());
+    console.println("update: end of list");
+}
+
+static void updateStep() {
+    if (!updateWatch || update->giteaBusy()) return;
+#ifdef RORO_DEBUG
+    if (updateWatch == 3) {
+        console.printf("update: probe: %s\n", update->probeResult().c_str());
+        updateWatch = 0;
+        return;
+    }
+#endif
+    printReleases(updateWatch == 2);
+    updateWatch = 0;
+}
+
+static void updateCommand(const String& args) {
+    if (args == "check" || args == "list") {
+        if (update->giteaBusy()) return (void)console.println("update: busy");
+        args == "check" ? update->requestCheck() : update->requestList();
+        updateWatch = args == "check" ? 1 : 2;
+    } else if (args == "status") {
+        GiteaReleases& g = update->gitea();
+        console.printf("update: running %s, failed here before: %s, daily check %s, heap %u\n", update->runningVersion().c_str(),
+                       update->failedVersion().empty() ? "none" : update->failedVersion().c_str(),
+                       settings.getBool(Setting::CheckUpdates) ? "on" : "off", (unsigned)ESP.getFreeHeap());
+        console.printf("update: gitea %s %s\n", g.status() == GiteaReleases::Status::Done ? "done" : g.status() == GiteaReleases::Status::Failed ? "failed" : g.status() == GiteaReleases::Status::Busy ? "busy" : "never asked", g.error().c_str());
+        printReleases(false);
+    } else if (args.startsWith("install ")) {
+        String rest = args.substring(8);
+        bool force = rest.endsWith(" force");
+        if (force) rest.remove(rest.length() - 6);
+#ifndef RORO_DEBUG
+        force = false;  // only the Debug Console may install on a Debug Build, which a release isn't
+#endif
+        std::string why = update->requestInstall(rest.c_str(), force);
+        console.printf("update: %s\n", why.empty() ? "installing" : why.c_str());
+#ifdef RORO_DEBUG
+    } else if (args.startsWith("probe ")) {  // update probe <host> [path]: is that server's certificate accepted?
+        String rest = args.substring(6);
+        int space = rest.indexOf(' ');
+        update->requestProbe((space < 0 ? rest : rest.substring(0, space)).c_str(), space < 0 ? "/" : rest.substring(space + 1).c_str());
+        updateWatch = 3;
+    } else if (args.startsWith("damage ")) {  // update damage cut <bytes> | flip <offset>: for the next download
+        long n = args.substring(args.lastIndexOf(' ') + 1).toInt();
+        args.startsWith("damage cut") ? update->damageNextDownload(n, -1) : update->damageNextDownload(-1, n);
+        console.printf("update: the next download will be %s at byte %ld\n", args.startsWith("damage cut") ? "cut" : "damaged", n);
+
+    } else if (args == "daily") {  // forget today's check: the daily one runs again at once, if it may
+        update->forgetToday();
+        console.println("update: the daily check will run at the next tick if Wi-Fi, the clock and memory allow");
+    } else if (args.startsWith("pretend ")) {  // update pretend v0.9.0 | off: what the comparisons take as running
+        update->pretendVersion(args.substring(8) == "off" ? "" : args.substring(8).c_str());
+        console.printf("update: running %s\n", update->runningVersion().c_str());
+#endif
+    } else {
+        console.println("update: check | list | status | install <tag>");
+    }
+}
+
+static void fileCommand(const String& line) {
+    int space = line.indexOf(' ');
+    std::string command = line.substring(0, space).c_str(), rest = line.substring(space + 1).c_str();
+    bool force = rest.rfind("-f ", 0) == 0;  // replace what's there
+    if (force) rest = rest.substr(3);
+    size_t split = rest.find('\t');  // two paths: a tab between them if either has a space
+    if (split == std::string::npos) split = rest.find(' ');
+    std::string a = rest.substr(0, split), b = split == std::string::npos ? "" : rest.substr(split + 1);
+    std::string why;
+    bool exists = false, folder = false;
+    if (command == "cancel") return fileOps->cancel();
+    if (!storageService->state().present) why = "no SD card";
+    else if (command == "du") why = fileOps->count(rest);
+    else if (command == "mkdir") why = fileOps->makeFolder(rest);
+    else if (command == "rm") {
+        folder = fileOps->isFolder(rest, exists);
+        why = exists ? fileOps->remove(rest, folder) : "It isn't there";
+    } else if (b.empty()) why = "two paths, please";
+    else {
+        folder = fileOps->isFolder(a, exists);
+        bool intoExists = false;
+        bool into = fileOps->isFolder(b, intoExists);  // `cp a /folder` keeps the name
+        if (!exists) why = "It isn't there";
+        else if (command == "cp") why = into ? fileOps->copy(a, folder, b, files::baseName(a), force) : fileOps->copy(a, folder, files::parentOf(b), files::baseName(b), force);
+        else why = fileOps->move(a, folder, into ? files::joinPath(b, files::baseName(a)) : b, force);
+    }
+    if (!why.empty()) return (void)console.printf("%s: error %s\n", command.c_str(), why.c_str());
+    consoleFileOp = true;
+}
+
+static uint32_t loopPasses = 0;  // counted in loop(), for `tasks` (issue #40)
+#ifdef RORO_DEBUG
+static bool loopSpin = false;  // `loop spin on`: no rest between passes, to compare load and radio noise
+#endif
+static uint32_t tasksPasses = 0;
+
+static void tasksStep() {
+    if (!tasksPending || static_cast<int32_t>(millis() - tasksDueMs) < 0) return;
+    tasksPending = false;
+    system_info::printTasks(console, tasksBefore, tasksTotal);
+    console.printf("loop: %lu passes in the last second, chip %.1f C\n", (unsigned long)(loopPasses - tasksPasses), temperatureRead());
+    std::vector<TaskSample>().swap(tasksBefore);
+}
+
 static const char* const kHelp =
    "info              firmware, uptime, memory, Wi-Fi, app slots\n"
-    "tasks             FreeRTOS tasks: state, priority, free stack, CPU\n"
+    "tasks             FreeRTOS tasks over the next second: state, priority, free stack, CPU share\n"    "net               bytes each network service has read and written since boot\n"
    "reboot            restart\n"
    "boot other        restart into the other app slot (manual Rollback)\n"
    "log level <0-5>   ESP-IDF log level (0 none ... 5 verbose)\n"
+    "ls [folder] | du <path> | mkdir <path> | rm <path> | cp [-f] <from> <to> | mv [-f] <from> <to> | cancel   the SD card, with the Storage App's rules\n"
    "lora probe | lora status | lora rx on|off | lora preset <name>   the LoRa radio, receive only\n"
    "lora capture start|stop   a LoRa Capture to /captures/lora (pcap, LoRaTap)\n"
    "lora sweep on [from MHz] [to MHz] [step kHz] | off | dump   RSSI across a band (863 870 100)\n"
    "lora custom <MHz> <BW kHz> <SF> <CR 5-8> <sync hex> [preamble]   e.g. 868.1 125 7 5 34 8 (LoRaWAN)\n"
+    "gnss quiet on|off   pause the GNSS receiver while the LoRa radio listens (it costs the radio 8 dB)\n"
    "gnss status | gnss restart | gnss track start|stop | gnss nmea on|off | gnss send <sentence without $ and checksum>\n"
    "crash             the last crash: firmware, reason, task, backtrace\n"
    "coredump erase    forget the core dump in flash\n"
@@ -400,12 +587,16 @@ static const char* const kHelp =
    "wifi dns <a> [b] | wifi dns always on|off | wifi ntp <a> [b]   DNS and NTP servers\n"
    "gemini get <url>  fetch a Gemini page and report header, size, certificate, heap\n"
    "irc start | irc stop | irc dump | irc say <buffer> <text>\n"
-    "ls [folder] | rm <path> | install <path.ota> (Update from SD)\n"
+    "install <path.ota>   Update from SD\n"
+    "update check | list | status | install <tag>   the project's releases on Gitea\n"
    "sd card | sd list | cat <path> | log <text> | burst | sound on|off | short | normal\n"
 #ifdef RORO_DEBUG
    "crash abort|wdt   crash on purpose (to test crash reports and Safe Mode)\n"
    "wifi ip ... try <seconds> | wifi ip keep   a trial IP setting: back to the previous one unless kept\n"
+    "loop spin on|off  make the main loop spin without resting, to compare load and radio noise\n"
+    "lora noise test [gnss|quiet] | lora noise report   Sweep under one changed condition at a time (Wi-Fi goes off for a moment)\n"
    "lora inject <hex> [rssi] [snr]   a packet into the LoRa Scanner as if received (nothing is sent)\n"
+    "sd fill <folder> <count>   makes that many small files there, to test a crowded folder\n"
    "coredump get      (Debug Console only) send the raw core dump: use scripts/rdbg.py coredump\n"
    "reset             (Debug Console only) restart at once, even if the main loop is stuck\n"
    "get <path> | put <path> <size> <sha256> | screenshot   (Debug Console only) binary, see rdbg.py\n"
@@ -415,7 +606,7 @@ static const char* const kHelp =

 // Commands that only touch what Safe Mode starts.
 static bool safeModeCommand(const String& line) {
-    return line == "help" || line == "info" || line == "tasks" || line == "reboot" || line == "boot other" ||
+    return line == "help" || line == "info" || line == "tasks" || line == "net" || line == "reboot" || line == "boot other" ||
           line.startsWith("log level ") || line.startsWith("crash") || line.startsWith("coredump") ||
           line == "wifi status" || line.startsWith("wifi add ");
 }
@@ -432,7 +623,25 @@ static void runCommand(String line) {
        console.printf("update: %s\n", update->onProbation() ? "on probation" : "confirmed");
        system_info::printSlots(console, nvs);
    }
-    if (line == "tasks") system_info::printTasks(console);
+#ifdef RORO_DEBUG
+    if (line == "loop spin on" || line == "loop spin off") {
+        loopSpin = line.endsWith("on");
+        console.printf("loop: %s\n", loopSpin ? "spinning, no rest" : "resting between passes");
+    }
+#endif
+    if (line == "tasks") {  // sampled now, printed a second later by tasksStep(): the loop must run in between
+        tasksTotal = system_info::sampleTasks(tasksBefore);
+        tasksDueMs = millis() + 1000;
+        tasksPasses = loopPasses;
+        tasksPending = true;
+    }
+    if (line == "net") {  // bytes each service has read and written since boot (S1, Q121)
+        for (int i = 0; i < static_cast<int>(net::User::Count); i++) {
+            net::Traffic t = net::traffic(static_cast<net::User>(i));
+            console.printf("net: %-14s in %10lu  out %10lu\n", net::userName(static_cast<net::User>(i)), (unsigned long)t.in,
+                           (unsigned long)t.out);
+        }
+    }
    if (line == "reboot") {
        console.println("restarting");
        delay(300);
@@ -444,23 +653,112 @@ static void runCommand(String line) {
        esp_log_level_set("*", static_cast<esp_log_level_t>(constrain(level, 0, 5)));
        console.printf("log level: %d\n", constrain(level, 0, 5));
    }
-    if (line == "ls" || line.startsWith("ls ") || line.startsWith("rm ")) {
+    if (line.startsWith("update ")) updateCommand(line.substring(7));
+    if (line.startsWith("cp ") || line.startsWith("mv ") || line.startsWith("rm ") || line.startsWith("mkdir ") ||
+        line.startsWith("du ") || line == "cancel")
+        fileCommand(line);
+    if (line == "ls" || line.startsWith("ls ")) {
        if (!storageService->state().present) return (void)console.println("sd: no card");
-        bool list = !line.startsWith("rm ");
        std::string path = line.length() > 3 ? line.substring(3).c_str() : "/";
-        storageService->runJob([list, path]() {  // card access stays on the storage task
-            if (!list) return (void)console.printf("rm: %s %s\n", path.c_str(), SD.remove(path.c_str()) ? "removed" : "failed");
+        storageService->runJob([path]() {  // card access stays on the storage task
            File dir = SD.open(path.c_str());
            if (!dir || !dir.isDirectory()) return (void)console.printf("ls: %s is not a folder\n", path.c_str());
            for (File f = dir.openNextFile(); f; f = dir.openNextFile())
-                console.printf("%10u  %s%s\n", f.isDirectory() ? 0u : (unsigned)f.size(), f.name(), f.isDirectory() ? "/" : "");
+                console.printf("%10u  %-16s  %s%s\n", f.isDirectory() ? 0u : (unsigned)f.size(),
+                               files::formatStamp(static_cast<uint32_t>(f.getLastWrite())).c_str(), f.name(), f.isDirectory() ? "/" : "");
            console.printf("ls: end of %s\n", path.c_str());
        });
    }
    if (line.startsWith("install ")) update->installFromSd(line.substring(8).c_str());  // Update from SD
+#ifdef RORO_DEBUG
+    if (line.startsWith("sd fill ")) {  // sd fill <folder> <count>: small files, to test a crowded folder
+        int space = line.lastIndexOf(' ');
+        std::string folder = line.substring(8, space).c_str();
+        int count = constrain(line.substring(space + 1).toInt(), 0, 1000);
+        storageService->runJob([folder, count]() {
+            int made = 0;
+            for (int i = 1; i <= count; i++) {
+                char name[24];
+                snprintf(name, sizeof name, "file-%04d.txt", i);
+                File f = SD.open(files::joinPath(folder, name).c_str(), FILE_WRITE);
+                if (!f) break;
+                f.printf("file %d\n", i);
+                f.close();
+                made++;
+            }
+            console.printf("sd fill: %d files in %s\n", made, folder.c_str());
+        });
+    }
+#endif
    if (line == "lora probe" && radioService) radioService->probe(console);
    if (line == "lora status" && radioService) radioService->printStatus(console);
    if ((line == "lora rx on" || line == "lora rx off") && radioService) radioService->setEcho(line.endsWith("on"));
+#ifdef RORO_DEBUG
+    if (line == "lora noise report" && noiseTest) noiseTest->printReport(console);
+    if (line == "lora noise test" && noiseTest && !noiseTest->running()) {
+        // One thing changed at a time, each put back before the next (issue #20). Wi-Fi off cuts the
+        // Debug Console: the report prints when it's over, and `lora noise report` shows it again.
+        using C = NoiseTest::Condition;
+        auto radioOptions = [](bool ldo, bool boosted) { return [=]() { radioService->debugOptions(ldo, boosted); }; };
+        std::vector<C> conditions = {
+            {"as it is", nullptr, nullptr},
+            {"loop spinning", []() { loopSpin = true; }, []() { loopSpin = false; }},
+            {"GNSS in standby", []() { gnssService->send("PCAS12,30"); }, []() { gnssService->restart(millis()); }, 2500},
+            {"CPU at 160 MHz", []() { setCpuFrequencyMhz(160); }, []() { setCpuFrequencyMhz(240); }},
+            {"CPU at 80 MHz", []() { setCpuFrequencyMhz(80); }, []() { setCpuFrequencyMhz(240); }},
+            {"radio regulator: LDO", radioOptions(true, true), radioOptions(false, true)},
+            {"radio gain not boosted", radioOptions(false, false), radioOptions(false, true)},
+            {"as it is, again", nullptr, nullptr},
+            {"Wi-Fi off", []() { wifi->debugPause(true); }, []() { wifi->debugPause(false); }, 4000},
+            {"screen on", []() { power->onKey(millis()); }, nullptr, 1000},
+            {"as it is, at the end", nullptr, nullptr, 8000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+    if (line == "lora noise test quiet" && noiseTest && !noiseTest->running()) {
+        // The same conditions as the first test, with the GNSS receiver in standby throughout: with
+        // the loudest source out of the way, what else shows?
+        using C = NoiseTest::Condition;
+        auto radioOptions = [](bool ldo, bool boosted) { return [=]() { radioService->debugOptions(ldo, boosted); }; };
+        std::vector<C> conditions = {
+            {"GNSS on (reference)", nullptr, nullptr},
+            {"GNSS in standby", []() { gnssService->send("PCAS12,300"); }, nullptr, 2500},
+            {"+ loop spinning", []() { loopSpin = true; }, []() { loopSpin = false; }},
+            {"+ CPU at 160 MHz", []() { setCpuFrequencyMhz(160); }, []() { setCpuFrequencyMhz(240); }},
+            {"+ CPU at 80 MHz", []() { setCpuFrequencyMhz(80); }, []() { setCpuFrequencyMhz(240); }},
+            {"+ radio regulator: LDO", radioOptions(true, true), radioOptions(false, true)},
+            {"+ radio gain not boosted", radioOptions(false, false), radioOptions(false, true)},
+            {"GNSS in standby, again", nullptr, nullptr},
+            {"+ Wi-Fi off", []() { wifi->debugPause(true); }, []() { wifi->debugPause(false); }, 4000},
+            {"+ screen on", []() { power->onKey(millis()); }, nullptr, 1000},
+            {"+ antenna switched off", []() { radioService->debugAntenna(false); }, []() { radioService->debugAntenna(true); }},
+            {"+ antenna off, gain not boosted", []() { radioService->debugAntenna(false); radioService->debugOptions(false, false); },
+             []() { radioService->debugAntenna(true); radioService->debugOptions(false, true); }},
+            {"GNSS in standby, at the end", nullptr, []() { gnssService->restart(millis()); }, 8000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+    if (line == "lora noise test gnss" && noiseTest && !noiseTest->running()) {
+        // The first test pointed at the GNSS receiver. Is it the receiver working, or its serial
+        // line (about 20 sentences a second, next to the antenna)? Standby stops both; one sentence
+        // a second quietens the line and leaves the receiver tracking. PCAS03 picks the sentences:
+        // GGA, GLL, GSA, GSV, RMC, VTG, ZDA, ANT; all eight are on by default.
+        using C = NoiseTest::Condition;
+        auto standby = []() { gnssService->send("PCAS12,30"); };
+        auto wake = []() { gnssService->restart(millis()); };
+        std::vector<C> conditions = {
+            {"as it is", nullptr, nullptr},
+            {"GNSS in standby", standby, wake, 2500},
+            {"GNSS on again", nullptr, nullptr, 5000},
+            {"GNSS: RMC only", []() { gnssService->send("PCAS03,0,0,0,0,1,0,0,0,0,0,,,0,0"); },
+             []() { gnssService->send("PCAS03,1,1,1,1,1,1,1,1,0,0,,,0,0"); }, 2500},
+            {"GNSS: all sentences again", nullptr, nullptr, 3000},
+            {"GNSS in standby, again", standby, wake, 2500},
+            {"GNSS on again", nullptr, nullptr, 5000},
+        };
+        noiseTest->start(std::move(conditions));
+    }
+#endif
    if (line.startsWith("lora sweep") && radioService) {  // on [from MHz] [to MHz] [step kHz] | off | dump
        if (line == "lora sweep dump") radioService->printSweep(console);
        else if (line == "lora sweep off") {
@@ -508,6 +806,10 @@ static void runCommand(String line) {
        if (p) radioService->setPreset(*p);
        console.printf("lora preset: %s\n", p ? p->name : "unknown (LongFast LongSlow MediumSlow MediumFast ShortSlow ShortFast LongMod)");
    }
+    if (line == "gnss quiet on" || line == "gnss quiet off") {  // Settings > Pause GNSS for LoRa (issue #20)
+        settings.setBool(Setting::GnssQuietForLora, line.endsWith("on"));
+        console.printf("gnss quiet: %s\n", line.endsWith("on") ? "GNSS pauses while the LoRa radio listens" : "GNSS stays on");
+    }
    if (line == "gnss status" && gnssService) gnssService->printStatus(console, millis());
    if ((line == "gnss nmea on" || line == "gnss nmea off") && gnssService) gnssService->setEcho(line.endsWith("on"));
    if (line == "gnss restart" && gnssService) gnssService->restart(millis());
@@ -731,6 +1033,7 @@ static void loopSafeMode() {
    uint32_t now = millis();
    serialCommands();
    remoteCommands();
+    tasksStep();
    services.tick(now);
    bus.dispatch();
    noteStableOnce(now);
@@ -750,8 +1053,30 @@ static void loopSafeMode() {
    delay(10);
 }

+// How long the main loop rests after a pass (issue #40). Spinning, it made 50,000 passes a
+// second and kept core 1 100 % busy for nothing: keys are buffered by the keyboard controller,
+// the consoles and the radio have their own tasks, and no Service asks for a tick more often than
+// every 50 ms. Shorter with the screen on, so a key or a redraw never waits long.
+constexpr uint32_t kLoopRestScreenOnMs = 5;
+constexpr uint32_t kLoopRestScreenOffMs = 20;
+static void loopPass();
+
 void loop() {
-    if (safeMode) return loopSafeMode();
+    loopPasses++;
+    if (safeMode) {
+        loopSafeMode();
+        delay(kLoopRestScreenOnMs);
+        return;
+    }
+    loopPass();
+#ifdef RORO_DEBUG
+    if (loopSpin) return;
+#endif
+    if (upload.active()) return;  // a serial file transfer: every byte is read promptly
+    delay(power->screen() == ScreenState::Off ? kLoopRestScreenOffMs : kLoopRestScreenOnMs);
+}
+
+static void loopPass() {
 #ifdef RORO_TEST_CRASH
    // Test builds only (never in a release): crash during Probation to exercise Rollback.
    if (millis() > 5000) abort();
@@ -762,10 +1087,14 @@ void loop() {

    serialCommands();
    remoteCommands();
+    tasksStep();
 #ifdef RORO_DEBUG
    ipTrialStep();
+    if (noiseTest) noiseTest->step(now);
 #endif
    noteStableOnce(now);
+    updateStep();
+    fileOpsStep();
    uploadStep();
    printListingWhenReady();
    M5Cardputer.update();
@@ -777,6 +1106,10 @@ void loop() {
            for (auto& e : events) apps->handleKey(e);
    }

+    // Issue #20: the GNSS receiver costs the LoRa radio 8 dB while it runs. If the user chose so,
+    // it waits in standby while the radio listens or sweeps; never while a Track is recording.
+    gnssService->holdForLora(settings.getBool(Setting::GnssQuietForLora) && !gnssService->tracking() &&
+                             (radioService->listening() || radioService->sweeping()));
    services.tick(now);
    bus.dispatch();
    notifier->update(now);
@@ -0,0 +1,62 @@
+#pragma once
+
+namespace roro {
+
+// The roots this device trusts for what it fetches over HTTPS (docs/milestones/R1.md, Q162): the two
+// ISRG roots Let's Encrypt chains end in, not the framework's bundle of about 130 CAs. Public
+// certificates, from https://letsencrypt.org/certs/ (SHA-256 fingerprints below).
+//
+//   ISRG Root X1  RSA 4096    valid until 2035-06-04
+//     96:BC:EC:06:26:49:76:F3:74:60:77:9A:CF:28:C5:A7:CF:E8:A3:C0:AA:E1:1A:8F:FC:EE:05:C0:BD:DF:08:C6
+//   ISRG Root X2  ECDSA P-384 valid until 2040-09-17
+//     69:72:9B:8E:15:A8:6E:FC:17:7A:57:AF:B7:17:1D:FC:64:AD:D2:8C:2F:CA:8C:F1:50:7E:34:45:3C:CB:14:70
+//
+// If the server's CA ever changes, the next firmware has to carry the new root and come from the PC.
+inline constexpr char kTrustedRootsPem[] =
+    "-----BEGIN CERTIFICATE-----\n"
+    "MIIFazCCA1OgAwIBAgIRAIIQz7DSQONZRGPgu2OCiwAwDQYJKoZIhvcNAQELBQAw\n"
+    "TzELMAkGA1UEBhMCVVMxKTAnBgNVBAoTIEludGVybmV0IFNlY3VyaXR5IFJlc2Vh\n"
+    "cmNoIEdyb3VwMRUwEwYDVQQDEwxJU1JHIFJvb3QgWDEwHhcNMTUwNjA0MTEwNDM4\n"
+    "WhcNMzUwNjA0MTEwNDM4WjBPMQswCQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJu\n"
+    "ZXQgU2VjdXJpdHkgUmVzZWFyY2ggR3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBY\n"
+    "MTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBAK3oJHP0FDfzm54rVygc\n"
+    "h77ct984kIxuPOZXoHj3dcKi/vVqbvYATyjb3miGbESTtrFj/RQSa78f0uoxmyF+\n"
+    "0TM8ukj13Xnfs7j/EvEhmkvBioZxaUpmZmyPfjxwv60pIgbz5MDmgK7iS4+3mX6U\n"
+    "A5/TR5d8mUgjU+g4rk8Kb4Mu0UlXjIB0ttov0DiNewNwIRt18jA8+o+u3dpjq+sW\n"
+    "T8KOEUt+zwvo/7V3LvSye0rgTBIlDHCNAymg4VMk7BPZ7hm/ELNKjD+Jo2FR3qyH\n"
+    "B5T0Y3HsLuJvW5iB4YlcNHlsdu87kGJ55tukmi8mxdAQ4Q7e2RCOFvu396j3x+UC\n"
+    "B5iPNgiV5+I3lg02dZ77DnKxHZu8A/lJBdiB3QW0KtZB6awBdpUKD9jf1b0SHzUv\n"
+    "KBds0pjBqAlkd25HN7rOrFleaJ1/ctaJxQZBKT5ZPt0m9STJEadao0xAH0ahmbWn\n"
+    "OlFuhjuefXKnEgV4We0+UXgVCwOPjdAvBbI+e0ocS3MFEvzG6uBQE3xDk3SzynTn\n"
+    "jh8BCNAw1FtxNrQHusEwMFxIt4I7mKZ9YIqioymCzLq9gwQbooMDQaHWBfEbwrbw\n"
+    "qHyGO0aoSCqI3Haadr8faqU9GY/rOPNk3sgrDQoo//fb4hVC1CLQJ13hef4Y53CI\n"
+    "rU7m2Ys6xt0nUW7/vGT1M0NPAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwIBBjAPBgNV\n"
+    "HRMBAf8EBTADAQH/MB0GA1UdDgQWBBR5tFnme7bl5AFzgAiIyBpY9umbbjANBgkq\n"
+    "hkiG9w0BAQsFAAOCAgEAVR9YqbyyqFDQDLHYGmkgJykIrGF1XIpu+ILlaS/V9lZL\n"
+    "ubhzEFnTIZd+50xx+7LSYK05qAvqFyFWhfFQDlnrzuBZ6brJFe+GnY+EgPbk6ZGQ\n"
+    "3BebYhtF8GaV0nxvwuo77x/Py9auJ/GpsMiu/X1+mvoiBOv/2X/qkSsisRcOj/KK\n"
+    "NFtY2PwByVS5uCbMiogziUwthDyC3+6WVwW6LLv3xLfHTjuCvjHIInNzktHCgKQ5\n"
+    "ORAzI4JMPJ+GslWYHb4phowim57iaztXOoJwTdwJx4nLCgdNbOhdjsnvzqvHu7Ur\n"
+    "TkXWStAmzOVyyghqpZXjFaH3pO3JLF+l+/+sKAIuvtd7u+Nxe5AW0wdeRlN8NwdC\n"
+    "jNPElpzVmbUq4JUagEiuTDkHzsxHpFKVK7q4+63SM1N95R1NbdWhscdCb+ZAJzVc\n"
+    "oyi3B43njTOQ5yOf+1CceWxG1bQVs5ZufpsMljq4Ui0/1lvh+wjChP4kqKOJ2qxq\n"
+    "4RgqsahDYVvTH9w7jXbyLeiNdd8XM2w9U/t7y0Ff/9yi0GE44Za4rF2LN9d11TPA\n"
+    "mRGunUHBcnWEvgJBQl9nJEiU0Zsnvgc/ubhPgXRR4Xq37Z0j4r7g1SgEEzwxA57d\n"
+    "emyPxgcYxn/eR44/KJ4EBs+lVDR3veyJm+kXQ99b21/+jh5Xos1AnX5iItreGCc=\n"
+    "-----END CERTIFICATE-----\n"
+    "-----BEGIN CERTIFICATE-----\n"
+    "MIICGzCCAaGgAwIBAgIQQdKd0XLq7qeAwSxs6S+HUjAKBggqhkjOPQQDAzBPMQsw\n"
+    "CQYDVQQGEwJVUzEpMCcGA1UEChMgSW50ZXJuZXQgU2VjdXJpdHkgUmVzZWFyY2gg\n"
+    "R3JvdXAxFTATBgNVBAMTDElTUkcgUm9vdCBYMjAeFw0yMDA5MDQwMDAwMDBaFw00\n"
+    "MDA5MTcxNjAwMDBaME8xCzAJBgNVBAYTAlVTMSkwJwYDVQQKEyBJbnRlcm5ldCBT\n"
+    "ZWN1cml0eSBSZXNlYXJjaCBHcm91cDEVMBMGA1UEAxMMSVNSRyBSb290IFgyMHYw\n"
+    "EAYHKoZIzj0CAQYFK4EEACIDYgAEzZvVn4CDCuwJSvMWSj5cz3es3mcFDR0HttwW\n"
+    "+1qLFNvicWDEukWVEYmO6gbf9yoWHKS5xcUy4APgHoIYOIvXRdgKam7mAHf7AlF9\n"
+    "ItgKbppbd9/w+kHsOdx1ymgHDB/qo0IwQDAOBgNVHQ8BAf8EBAMCAQYwDwYDVR0T\n"
+    "AQH/BAUwAwEB/zAdBgNVHQ4EFgQUfEKWrt5LSDv6kviejM9ti6lyN5UwCgYIKoZI\n"
+    "zj0EAwMDaAAwZQIwe3lORlCEwkSHRhtFcP9Ymd70/aTSVaYgLXTWNLxBo1BfASdW\n"
+    "tL4ndQavEi51mI38AjEAi/V3bNTIZargCyzuFJ0nN6T5U6VR5CmD1/iQMVtCnwr1\n"
+    "/q4AaOeMSQ+2b1tbFfLn\n"
+    "-----END CERTIFICATE-----\n";
+
+}  // namespace roro
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+#include "traffic.h"
+
+namespace roro {
+
+// A NetworkClient (or NetworkClientSecure) that adds what it reads and writes to its service's
+// traffic counters (S1, Q121). Only the two buffer calls are overridden: the single-byte ones,
+// print() and printf() all go through them, so every byte is counted once.
+template <class Base>
+class Counted : public Base {
+   public:
+    explicit Counted(net::User user) : user_(user) {}
+    Counted(const Base& accepted, net::User user) : Base(accepted), user_(user) {}
+
+    // Overriding the buffer calls hides the single-byte ones; these put them back. They end up in
+    // the buffer calls below, where the counting happens.
+    int read() override { return Base::read(); }
+    size_t write(uint8_t byte) override { return Base::write(byte); }
+
+    size_t write(const uint8_t* buf, size_t size) override {
+        size_t n = Base::write(buf, size);
+        net::sent(user_, n);
+        return n;
+    }
+
+    int read(uint8_t* buf, size_t size) override {
+        int n = Base::read(buf, size);
+        if (n > 0) net::received(user_, static_cast<size_t>(n));
+        return n;
+    }
+
+   private:
+    net::User user_;
+};
+
+}  // namespace roro
@@ -0,0 +1,111 @@
+#include "platform/https_get.h"
+
+#include <Arduino.h>
+#include <esp_heap_caps.h>
+
+#include <algorithm>
+#include <ctime>
+
+#include "platform/ca_roots.h"
+#include "version.h"
+
+namespace roro {
+
+namespace {
+constexpr time_t kClockSetAfter = 1700000000;  // 2023-11: anything earlier is the clock's default
+
+// What mbedTLS says in the way it says it, for the cases a person can act on.
+std::string whyNotConnected(NetworkClientSecure& tls, const std::string& host) {
+    char text[100] = "";
+    int err = tls.lastError(text, sizeof text);
+    std::string detail = text;
+    if (detail.find("X509") != std::string::npos || detail.find("certificate") != std::string::npos)
+        return "The certificate of " + host + " isn't accepted";
+    if (err != 0 && !detail.empty()) return "TLS to " + host + ": " + detail;
+    return "Can't connect to " + host;
+}
+}  // namespace
+
+std::string HttpsGet::open(const std::string& host, const std::string& path, const char* accept) {
+    close();
+    if (time(nullptr) < kClockSetAfter) return "The clock isn't set: can't check certificates";
+    if (esp_get_free_heap_size() < kNeedFree) return "Not enough memory for a secure connection";
+
+    tls_.setCACert(kTrustedRootsPem);
+    tls_.setTimeout(15);
+    if (!tls_.connect(host.c_str(), 443)) return whyNotConnected(tls_, host);
+
+    raw_.reset(new (std::nothrow) uint8_t[kRaw]);
+    if (!raw_) return "Not enough memory";
+    tls_.print(("GET " + path + " HTTP/1.1\r\nHost: " + host + "\r\nUser-Agent: roro9stack/" + versionString() +
+                "\r\nAccept: " + accept + "\r\nAccept-Encoding: identity\r\nConnection: close\r\n\r\n")
+                   .c_str());
+
+    release::HttpHeadParser parser;
+    while (!parser.complete()) {
+        int n = readRaw(raw_.get(), kRaw);
+        if (n <= 0) return "The server " + host + " stopped answering";
+        size_t used = parser.feed(reinterpret_cast<const char*>(raw_.get()), n);
+        if (parser.failed()) return host + " didn't answer with HTTP";
+        if (parser.complete() && used < static_cast<size_t>(n)) early_.assign(reinterpret_cast<const char*>(raw_.get()) + used, n - used);
+    }
+    head_ = parser.head();
+    if (head_.status != 200) return host + " answered " + std::to_string(head_.status) + (head_.status / 100 == 3 ? " (a redirect)" : "");
+    left_ = head_.chunked ? -1 : head_.contentLength;
+    return "";
+}
+
+int HttpsGet::readRaw(uint8_t* into, size_t len) {
+    uint32_t since = millis();
+    while (!tls_.available()) {
+        if (!tls_.connected()) return 0;
+        if (millis() - since > kStallMs) return -1;
+        delay(5);
+    }
+    return tls_.read(into, len);
+}
+
+int HttpsGet::read(uint8_t* buf, size_t len) {
+    if (done_ || len == 0) return 0;
+    if (!head_.chunked && left_ == 0) return done_ = true, 0;
+
+    for (;;) {
+        // Raw bytes: first those that came with the head, then the connection's.
+        size_t want = head_.chunked ? std::min(len, kRaw) : len;
+        if (!head_.chunked && left_ > 0) want = std::min<size_t>(want, left_);
+        int n;
+        if (earlyAt_ < early_.size()) {
+            n = static_cast<int>(std::min(want, early_.size() - earlyAt_));
+            std::copy(early_.data() + earlyAt_, early_.data() + earlyAt_ + n, head_.chunked ? raw_.get() : buf);
+            earlyAt_ += n;
+        } else {
+            n = readRaw(head_.chunked ? raw_.get() : buf, want);
+        }
+        if (n < 0) return -1;
+        if (n == 0) {  // the server closed: the end, if it's where it said it would be
+            done_ = true;
+            bool whole = head_.chunked ? chunks_.done() : left_ <= 0;
+            return whole ? 0 : -1;
+        }
+        if (!head_.chunked) {
+            if (left_ > 0) left_ -= n;
+            return n;
+        }
+        size_t out = chunks_.decode(raw_.get(), n, buf);
+        if (chunks_.failed()) return -1;
+        if (out > 0) return static_cast<int>(out);
+        if (chunks_.done()) return done_ = true, 0;
+    }
+}
+
+void HttpsGet::close() {
+    tls_.stop();
+    raw_.reset();
+    std::string().swap(early_);
+    earlyAt_ = 0;
+    done_ = false;
+    head_ = release::HttpHead();
+    chunks_ = release::ChunkedDecoder();
+}
+
+}  // namespace roro
@@ -0,0 +1,51 @@
+#pragma once
+
+#include <NetworkClientSecure.h>
+
+#include <memory>
+#include <string>
+
+#include "http_head.h"
+#include "platform/counted_client.h"
+
+namespace roro {
+
+// One HTTPS GET, read as a stream: the connection checks the server's chain and name against the
+// roots in ca_roots.h, the head is parsed, and the body comes out whole whether the server sent it
+// with a length or in chunks. Used by the Update Service to read Gitea's answers and to download a
+// release. Redirects aren't followed: the device only goes where it was told to (Q163).
+class HttpsGet {
+   public:
+    // A TLS connection to Gitea peaks at about 52 KB of heap (measured: the same with or without
+    // checking the certificate); with Q86's 20 KB to spare, it starts with at least this much free.
+    static constexpr size_t kNeedFree = 80 * 1024;
+
+    explicit HttpsGet(net::User user) : tls_(user) {}
+    ~HttpsGet() { close(); }
+
+    // Connects and reads the head. "" when a 200 is on its way, or why not, in words for the screen.
+    std::string open(const std::string& host, const std::string& path, const char* accept);
+    long contentLength() const { return head_.contentLength; }  // -1: not known
+
+    // Body bytes into `buf`: how many, 0 at the end, -1 when the connection broke or stalled
+    // before the end.
+    int read(uint8_t* buf, size_t len);
+    void close();
+
+   private:
+    static constexpr size_t kRaw = 1024;
+    static constexpr uint32_t kStallMs = 10000;
+
+    int readRaw(uint8_t* into, size_t len);  // from the connection, waiting up to kStallMs
+
+    Counted<NetworkClientSecure> tls_;
+    release::HttpHead head_;
+    release::ChunkedDecoder chunks_;
+    std::unique_ptr<uint8_t[]> raw_;
+    std::string early_;  // body bytes that arrived with the head
+    size_t earlyAt_ = 0;
+    long left_ = -1;  // body bytes still to come, if the server said how many
+    bool done_ = false;
+};
+
+}  // namespace roro
@@ -7,6 +7,8 @@
 #include <freertos/FreeRTOS.h>
 #include <freertos/task.h>

+#include <algorithm>
+#include <cstdio>
 #include <string>
 #include <vector>

@@ -89,20 +91,40 @@ void printSlots(Print& out, KeyValueStore& store) {
    }
 }

-void printTasks(Print& out) {
+uint32_t sampleTasks(std::vector<TaskSample>& out) {
    UBaseType_t n = uxTaskGetNumberOfTasks();
    std::vector<TaskStatus_t> tasks(n + 4);
    uint32_t total = 0;
    n = uxTaskGetSystemState(tasks.data(), tasks.size(), &total);
-    out.printf("%-16s %-4s %3s %6s %5s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
-    static const char kStates[] = "RrBSD";  // running, ready, blocked, suspended, deleted
+    out.clear();
+    out.reserve(n);
    for (UBaseType_t i = 0; i < n; i++) {
        const TaskStatus_t& t = tasks[i];
-        unsigned cpu = total ? (unsigned)((uint64_t)t.ulRunTimeCounter * 100 / total) : 0;
-        int core = t.xCoreID == tskNO_AFFINITY ? -1 : (int)t.xCoreID;
-        out.printf("%-16s %-4c %3u %6u %5u %d\n", t.pcTaskName, t.eCurrentState < 5 ? kStates[t.eCurrentState] : '?',
-                   (unsigned)t.uxCurrentPriority, (unsigned)t.usStackHighWaterMark, cpu, core);
+        TaskSample s;
+        s.id = t.xTaskNumber;
+        std::snprintf(s.name, sizeof s.name, "%s", t.pcTaskName);
+        s.runtime = t.ulRunTimeCounter;
+        s.stackFree = static_cast<uint16_t>(std::min<uint32_t>(t.usStackHighWaterMark, 0xFFFF));
+        s.core = t.xCoreID == tskNO_AFFINITY ? -1 : static_cast<int8_t>(t.xCoreID);
+        s.state = static_cast<uint8_t>(t.eCurrentState);
+        s.priority = static_cast<uint8_t>(t.uxCurrentPriority);
+        out.push_back(s);
    }
+    return total;
+}
+
+// Shares over the interval since `before`, not since boot: the counters wrap every 71 minutes.
+void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal) {
+    std::vector<TaskSample> now;
+    uint32_t t1 = sampleTasks(now);
+    std::vector<TaskRow> rows = taskRows(before, beforeTotal, now, t1);
+    sortTasks(rows, TaskSort::Share);
+    out.printf("%-16s %-4s %3s %6s %6s %s\n", "task", "st", "pri", "stack", "cpu%", "core");
+    static const char kStates[] = "RrBSD";  // running, ready, blocked, suspended, deleted
+    for (const TaskRow& r : rows)
+        out.printf("%-16s %-4c %3u %6u %4u.%u %d%s\n", r.name.c_str(), r.state < 5 ? kStates[r.state] : '?', r.priority,
+                   r.stackFree, r.permille / 10, r.permille % 10, r.core, r.lowStack ? "  low stack" : "");
+    out.printf("load: core 0 %d %%, core 1 %d %%\n", coreLoad(rows, 0), coreLoad(rows, 1));
 }

 const char* bootOtherSlot() {
@@ -3,7 +3,10 @@
 #include <Print.h>
 #include <esp_partition.h>

+#include <vector>
+
 #include "key_value_store.h"
+#include "task_stats.h"

 namespace roro::system_info {

@@ -20,7 +23,12 @@ void printSlots(Print& out, KeyValueStore& store);
 // Remembers which version the running slot holds (call at boot), or the slot an update just wrote.
 void recordSlotVersion(KeyValueStore& store, const esp_partition_t* slot, const char* version);
 // FreeRTOS tasks: state, priority, lowest free stack, CPU share since boot.
-void printTasks(Print& out);
+// The tasks' shares since `before` was sampled (with its run-time clock). The caller lets the main
+// loop run in between: sampling twice inside one command would show the loop asleep.
+void printTasks(Print& out, const std::vector<TaskSample>& before, uint32_t beforeTotal);
+// Every task as FreeRTOS reports it now; returns the run-time clock (microseconds, 32 bits), to
+// pair with the samples. Two of these make the shares the System App and `tasks` show.
+uint32_t sampleTasks(std::vector<TaskSample>& out);

 // Boots the firmware in the other app slot if it holds a valid image (a manual Rollback).
 // Returns an error message; on success it restarts and doesn't return.
@@ -1,6 +1,7 @@
 #pragma once

 #include <Arduino.h>
+#include <sys/time.h>

 #include "clock_model.h"
 #include "event_bus.h"
@@ -20,7 +21,16 @@ class ClockService : public Service {
    const char* name() const override { return "clock"; }
    void start() override { applyTimezone(); }

-    bool set(int64_t utcSeconds, TimeSource source) { return model_.set(utcSeconds, source, millis()); }
+    bool set(int64_t utcSeconds, TimeSource source) {
+        if (!model_.set(utcSeconds, source, millis())) return false;
+        // The system's own clock too (F1, Q137): the card's files are dated from it, and NTP was
+        // the only thing setting it. NTP has just done so itself.
+        if (source != TimeSource::Ntp) {
+            timeval now = {static_cast<time_t>(utcSeconds), 0};
+            settimeofday(&now, nullptr);
+        }
+        return true;
+    }
    const ClockModel& model() const { return model_; }

    // UTC seconds, or -1 if the clock isn't set.
@@ -17,6 +17,7 @@
 #include "file_receiver.h"
 #include "sha256.h"
 #include "platform/console.h"
+#include "platform/counted_client.h"
 #include "sd_fault.h"
 #include "version.h"

@@ -110,7 +111,7 @@ void DebugConsole::listen() {
            listening = false;
        }
        if (listening) {
-            NetworkClient client = server.accept();
+            Counted<NetworkClient> client(server.accept(), net::User::DebugConsole);
            if (client) {
                client.setNoDelay(true);
                if (authenticate(client)) serve(client);
@@ -0,0 +1,492 @@
+#include "services/file_ops.h"
+
+#include <Arduino.h>
+#include <SD.h>
+
+#include <ctime>
+#include <memory>
+
+#include "file_names.h"
+
+namespace roro {
+
+using files::baseName;
+using files::joinPath;
+using files::parentOf;
+
+namespace {
+// The FatFs drive the card is mounted as: SDFS keeps it to itself.
+struct SdDrive : fs::SDFS {
+    static uint8_t of(fs::SDFS& sd) { return sd.*(&SdDrive::_pdrv); }
+};
+
+// A FAT date and time (local, as the firmware wrote them) as Unix time; 0 if there's none.
+uint32_t fatTime(uint16_t date, uint16_t time) {
+    if (date == 0) return 0;
+    struct tm t = {};
+    t.tm_year = (date >> 9) + 80;
+    t.tm_mon = ((date >> 5) & 15) - 1;
+    t.tm_mday = date & 31;
+    t.tm_hour = time >> 11;
+    t.tm_min = (time >> 5) & 63;
+    t.tm_sec = (time & 31) * 2;
+    t.tm_isdst = -1;
+    time_t at = mktime(&t);
+    return at < 0 ? 0 : static_cast<uint32_t>(at);
+}
+
+struct Guard {
+    explicit Guard(SemaphoreHandle_t l) : l_(l) { xSemaphoreTake(l_, portMAX_DELAY); }
+    ~Guard() { xSemaphoreGive(l_); }
+    SemaphoreHandle_t l_;
+};
+}  // namespace
+
+FileOps::FileOps(StorageService& storage, InUse inUse)
+    : storage_(storage), inUse_(std::move(inUse)), lock_(xSemaphoreCreateMutex()) {}
+
+FileOps::Status FileOps::status() const {
+    Guard g(lock_);
+    Status s = status_;
+    s.running = busy_;
+    s.doneBytes = doneBytes_;
+    s.files = files_;
+    return s;
+}
+
+bool FileOps::finished(Status& out) {
+    // The storage task drops its jobs when the card goes: nothing would ever end this one.
+    if (busy_ && !storage_.state().present) {
+        fail("The card went away");
+        busy_ = false;
+        done_ = true;
+    }
+    if (!done_.exchange(false)) return false;
+    out = status();
+    out.running = false;
+    return true;
+}
+
+void FileOps::takeListing(files::FileList& out) {
+    Guard g(lock_);
+    out = std::move(listing_);
+    listing_.clear();
+}
+
+bool FileOps::isFolder(const std::string& path, bool& exists) {
+    bool folder = false;
+    exists = false;
+    storage_.runAndWait([&]() {
+        fs::File f = SD.open(path.c_str());
+        exists = static_cast<bool>(f);
+        folder = f && f.isDirectory();
+    });
+    return folder;
+}
+
+std::string FileOps::whyReadOnly(const std::string& path, bool folder) const {
+    return files::whyReadOnly(path, inUse_(path, folder));
+}
+
+std::string FileOps::start(Op op, const std::string& path) {
+    if (busy_) return "The card is busy with something else";
+    if (!storage_.state().present) return "No SD card";
+    {
+        Guard g(lock_);
+        status_ = Status();
+        status_.op = op;
+        status_.path = path;
+    }
+    closeAll();  // only handles a vanished card left behind
+    listOpen_ = false;
+    op_ = op;
+    phase_ = 0;
+    undo_ = false;
+    cancel_ = false;
+    done_ = false;
+    doneBytes_ = 0;
+    files_ = 0;
+    countBytes_ = 0;
+    startMs_ = millis();
+    busy_ = true;
+    queue();
+    return "";
+}
+
+void FileOps::queue() {
+    storage_.runJob([this]() { slice(); });
+}
+
+std::string FileOps::list(const std::string& folder) {
+    from_ = folder;
+    return start(Op::List, folder);
+}
+
+std::string FileOps::count(const std::string& path) {
+    from_ = path;
+    return start(Op::Count, path);
+}
+
+std::string FileOps::copy(const std::string& from, bool folder, const std::string& intoFolder, const std::string& name, bool replace) {
+    if (busy_) return "The card is busy with something else";
+    std::string why = files::whyNotInto(from, intoFolder);
+    // A copy next to its original is fine: only the name must differ.
+    if (why == "It's already there" && name != baseName(from)) why.clear();
+    if (why.empty()) why = files::checkName(name);
+    if (!why.empty()) return why;
+    from_ = from;
+    to_ = joinPath(intoFolder, name);
+    replace_ = replace;
+    sourceIsFolder_ = folder;
+    return start(Op::Copy, from);
+}
+
+std::string FileOps::move(const std::string& from, bool folder, const std::string& to, bool replace) {
+    if (busy_) return "The card is busy with something else";
+    std::string why = files::whyReadOnly(from, inUse_(from, folder));
+    if (why.empty() && from == to) why = "It's already there";
+    if (why.empty() && parentOf(to) != parentOf(from)) why = files::whyNotInto(from, parentOf(to));
+    if (why.empty()) why = files::checkName(baseName(to));
+    if (!why.empty()) return why;
+    from_ = from;
+    to_ = to;
+    replace_ = replace;
+    sourceIsFolder_ = folder;
+    return start(Op::Move, from);
+}
+
+std::string FileOps::remove(const std::string& path, bool folder) {
+    if (busy_) return "The card is busy with something else";
+    std::string why = files::whyReadOnly(path, inUse_(path, folder));
+    if (!why.empty()) return why;
+    from_ = path;
+    sourceIsFolder_ = folder;
+    return start(Op::Delete, path);
+}
+
+std::string FileOps::makeFolder(const std::string& path) {
+    if (busy_) return "The card is busy with something else";
+    std::string why = files::checkName(baseName(path));
+    if (why.empty() && files::isInside(path, files::kGeminiCache)) why = std::string(files::kGeminiCache) + " is the Gemini App's working space";
+    if (!why.empty()) return why;
+    from_ = path;
+    return start(Op::MakeFolder, path);
+}
+
+void FileOps::fail(const std::string& why) {
+    Guard g(lock_);
+    if (status_.error.empty()) status_.error = why;
+}
+
+void FileOps::closeAll() {
+    if (in_) in_.close();
+    if (out_) out_.close();
+    for (auto& d : dirs_)
+        if (d) d.close();
+    dirs_.clear();
+    paths_.clear();
+}
+
+void FileOps::finish() {
+    if (listOpen_) f_closedir(&listDir_);
+    listOpen_ = false;
+    closeAll();
+    {
+        Guard g(lock_);
+        status_.cancelled = cancel_ && status_.error.empty() && (op_ == Op::Copy || op_ == Op::Delete || op_ == Op::Count);
+        status_.bytes = countBytes_;
+        status_.ms = millis() - startMs_;
+    }
+    op_ = Op::None;
+    busy_ = false;
+    done_ = true;
+}
+
+bool FileOps::enter(const std::string& path) {
+    fs::File d = SD.open(path.c_str());
+    if (!d || !d.isDirectory()) return false;
+    dirs_.push_back(d);
+    paths_.push_back(path);
+    return true;
+}
+
+// One slice on the storage task, then back in the queue behind whatever else is waiting.
+void FileOps::slice() {
+    if (!busy_) return;  // given up on: the card went away (finished())
+    bool over = true;
+    switch (op_) {
+        case Op::List: over = sliceList(); break;
+        case Op::Count: over = sliceCount(); break;
+        case Op::Copy: over = sliceCopy(); break;
+        case Op::Delete: over = sliceDelete(); break;
+        case Op::Move: {
+            if (!SD.exists(from_.c_str())) fail("It isn't there any more");
+            else if (SD.exists(to_.c_str()) && !replace_) {
+                Guard g(lock_);
+                status_.exists = true;
+                status_.error = baseName(to_) + " exists already";
+            } else {
+                if (SD.exists(to_.c_str())) SD.remove(to_.c_str());  // a file: a folder in the way makes the rename fail
+                if (!SD.rename(from_.c_str(), to_.c_str())) fail("The card refused to move it");
+                else files_ = 1;
+            }
+            break;
+        }
+        case Op::MakeFolder:
+            if (SD.exists(from_.c_str())) fail(baseName(from_) + " exists already");
+            else if (!SD.mkdir(from_.c_str())) fail("The card refused to make the folder");
+            break;
+        default: break;
+    }
+    if (over) finish();
+    else queue();
+}
+
+// Straight from FatFs, one pass over the folder: the Arduino File looks every entry up by name
+// again for its size and its date, which made 300 entries take over two seconds.
+bool FileOps::sliceList() {
+    uint32_t t0 = millis();
+    if (phase_ == 0) {
+        Guard g(lock_);
+        listing_.clear();
+        std::string path = std::string(1, static_cast<char>('0' + SdDrive::of(SD))) + ":" + from_;
+        if (f_opendir(&listDir_, path.c_str()) != FR_OK) {
+            status_.error = from_ + " isn't a folder";
+            return true;
+        }
+        listOpen_ = true;
+        phase_ = 1;
+    }
+    while (millis() - t0 < kSliceMs) {
+        if (cancel_) return true;
+        FILINFO info;
+        if (f_readdir(&listDir_, &info) != FR_OK || info.fname[0] == 0) return true;
+        bool folder = info.fattrib & AM_DIR;
+        Guard g(lock_);
+        listing_.add(info.fname, folder ? 0 : static_cast<uint32_t>(info.fsize), fatTime(info.fdate, info.ftime), folder);
+    }
+    return false;
+}
+
+// What's inside, for "Delete saved and its 42 files?" (Q132) and for a copy's total.
+bool FileOps::sliceCount() {
+    uint32_t t0 = millis();
+    if (phase_ == 0) {
+        phase_ = 1;
+        fs::File f = SD.open(from_.c_str());
+        if (!f) {
+            fail("It isn't there any more");
+            return true;
+        }
+        if (!f.isDirectory()) {
+            files_ = 1;
+            countBytes_ = static_cast<uint32_t>(f.size());
+            return true;
+        }
+        f.close();
+        enter(from_);
+    }
+    while (!dirs_.empty() && millis() - t0 < kSliceMs) {
+        if (cancel_) return true;
+        fs::File f = dirs_.back().openNextFile();
+        if (!f) {
+            dirs_.back().close();
+            dirs_.pop_back();
+            paths_.pop_back();
+        } else if (f.isDirectory()) {
+            std::string sub = joinPath(paths_.back(), f.name());
+            f.close();
+            enter(sub);
+        } else {
+            files_++;
+            countBytes_ += static_cast<uint32_t>(f.size());
+        }
+    }
+    return dirs_.empty();
+}
+
+// Deletes files as the walk meets them and each folder once it's empty. Also how a cancelled or
+// failed copy takes back what it had written (undo_).
+bool FileOps::sliceDelete() {
+    uint32_t t0 = millis();
+    if (phase_ == 0) {
+        phase_ = 1;
+        fs::File f = SD.open(from_.c_str());
+        if (!f) {
+            if (!undo_) fail("It isn't there any more");
+            return true;
+        }
+        bool folder = f.isDirectory();
+        f.close();
+        if (!folder) {
+            if (!SD.remove(from_.c_str())) fail("The card refused to delete it");
+            else if (!undo_) files_ = 1;
+            return true;
+        }
+        enter(from_);
+    }
+    while (!dirs_.empty() && millis() - t0 < kSliceMs) {
+        if (cancel_ && !undo_) return true;  // what's deleted stays deleted
+        fs::File f = dirs_.back().openNextFile();
+        if (!f) {
+            std::string done = paths_.back();
+            dirs_.back().close();
+            dirs_.pop_back();
+            paths_.pop_back();
+            if (!SD.rmdir(done.c_str())) {
+                fail("The card refused to delete " + baseName(done));
+                return true;
+            }
+        } else if (f.isDirectory()) {
+            std::string sub = joinPath(paths_.back(), f.name());
+            f.close();
+            if (!enter(sub)) {
+                fail("The card refused to open " + baseName(sub));
+                return true;
+            }
+        } else {
+            std::string path = joinPath(paths_.back(), f.name());
+            f.close();
+            if (!SD.remove(path.c_str())) {
+                fail("The card refused to delete " + baseName(path));
+                return true;
+            }
+            if (!undo_) files_++;
+        }
+    }
+    return dirs_.empty();
+}
+
+// Phases 0 and 1 count the source (the walk of Count), 2 checks and prepares, 3 copies, 4 takes
+// a failed or cancelled copy back.
+bool FileOps::sliceCopy() {
+    uint32_t t0 = millis();
+    if (phase_ <= 1) {
+        if (!sliceCount()) return false;
+        phase_ = 2;
+    }
+    if (phase_ == 2) {
+        {
+            Guard g(lock_);
+            if (!status_.error.empty()) return true;
+            status_.totalBytes = countBytes_;
+        }
+        if (cancel_) return true;
+        files_ = 0;
+        StorageState card = storage_.state();
+        if (card.totalBytes - card.usedBytes < static_cast<uint64_t>(countBytes_) + 64 * 1024) {
+            fail("Not enough room on the card");
+            return true;
+        }
+        if (SD.exists(to_.c_str())) {
+            if (!replace_) {
+                Guard g(lock_);
+                status_.exists = true;
+                status_.error = baseName(to_) + " exists already";
+                return true;
+            }
+            if (sourceIsFolder_) {
+                fail("A folder with that name is in the way");
+                return true;
+            }
+            SD.remove(to_.c_str());
+        }
+        if (sourceIsFolder_) {
+            if (!SD.mkdir(to_.c_str()) || !enter(from_)) {
+                fail("The card refused to make the folder");
+                return true;
+            }
+        } else {
+            in_ = SD.open(from_.c_str(), FILE_READ);
+            outPath_ = to_;
+            out_ = SD.open(outPath_.c_str(), FILE_WRITE);
+            fileBytes_ = 0;
+            fileSize_ = in_ ? static_cast<uint32_t>(in_.size()) : 0;
+            if (!in_ || !out_) {
+                fail("The card refused to open the files");
+                phase_ = 4;
+                return false;
+            }
+        }
+        phase_ = 3;
+    }
+    if (phase_ == 3) {
+        std::unique_ptr<uint8_t[]> piece(new uint8_t[kPiece]);
+        while (millis() - t0 < kSliceMs) {
+            if (cancel_) {
+                phase_ = 4;
+                return false;
+            }
+            if (in_) {  // a file in progress
+                int n = in_.read(piece.get(), kPiece);
+                if (n > 0 && out_.write(piece.get(), n) != static_cast<size_t>(n)) n = -1;
+                if (n < 0) {
+                    fail("The card refused a write");
+                    phase_ = 4;
+                    return false;
+                }
+                if (n > 0) {
+                    doneBytes_ += n;
+                    fileBytes_ += n;
+                    continue;
+                }
+                in_.close();
+                out_.close();
+                // Q133: the sizes are compared. A Log that grew meanwhile is copied as far as it went.
+                fs::File check = SD.open(outPath_.c_str(), FILE_READ);
+                bool same = check && static_cast<uint32_t>(check.size()) == fileBytes_ && fileBytes_ >= fileSize_;
+                if (check) check.close();
+                if (!same) {
+                    fail("The copy of " + baseName(outPath_) + " isn't the size of the original");
+                    phase_ = 4;
+                    return false;
+                }
+                files_++;
+                continue;
+            }
+            if (dirs_.empty()) return true;  // a single file, or the whole folder: done
+            fs::File f = dirs_.back().openNextFile();
+            // The copy sits where the original does, relative to the two roots.
+            auto target = [&](const std::string& source) { return to_ + source.substr(from_.size()); };
+            if (!f) {
+                dirs_.back().close();
+                dirs_.pop_back();
+                paths_.pop_back();
+            } else if (f.isDirectory()) {
+                std::string sub = joinPath(paths_.back(), f.name());
+                f.close();
+                if (!SD.mkdir(target(sub).c_str()) || !enter(sub)) {
+                    fail("The card refused to make " + baseName(sub));
+                    phase_ = 4;
+                    return false;
+                }
+            } else {
+                std::string source = joinPath(paths_.back(), f.name());
+                f.close();
+                in_ = SD.open(source.c_str(), FILE_READ);
+                outPath_ = target(source);
+                out_ = SD.open(outPath_.c_str(), FILE_WRITE);
+                fileBytes_ = 0;
+                fileSize_ = in_ ? static_cast<uint32_t>(in_.size()) : 0;
+                if (!in_ || !out_) {
+                    fail("The card refused to open " + baseName(source));
+                    phase_ = 4;
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
+    // Phase 4: take it back. The copy never replaced a folder, so everything under to_ is ours.
+    if (!undo_) {
+        closeAll();
+        undo_ = true;
+        from_ = to_;
+        phase_ = 0;
+        op_ = Op::Delete;  // finish() reports it as the copy it was: status_.op stays Copy
+        return false;
+    }
+    return true;
+}
+
+}  // namespace roro
@@ -0,0 +1,102 @@
+#pragma once
+
+#include <FS.h>
+#include <ff.h>
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+#include <atomic>
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "file_list.h"
+#include "services/storage_service.h"
+
+namespace roro {
+
+// What the Storage App does to the card (docs/milestones/F1.md): list a folder, count what's in
+// one, copy, move, delete, make a folder. One operation at a time, on the storage task like every
+// card access, **in slices of about 150 ms**: a long copy re-queues itself between slices, so IRC
+// Logs, a Gemini page streaming to the card or a Capture are written in between and nobody waits
+// long enough to give up. The read-only rules of Q130 are checked here, whoever asks.
+class FileOps {
+   public:
+    enum class Op : uint8_t { None, List, Count, Copy, Move, Delete, MakeFolder };
+    // The files the firmware has open right now that matter for `path` (a folder or not).
+    using InUse = std::function<std::vector<std::string>(const std::string& path, bool folder)>;
+
+    struct Status {
+        Op op = Op::None;
+        bool running = false;
+        bool cancelled = false;
+        bool exists = false;   // a copy or move found something with that name: ask, then `replace`
+        std::string error;     // why it failed, for a human; empty when it worked
+        uint32_t doneBytes = 0, totalBytes = 0;  // a copy's progress
+        uint32_t files = 0;    // files copied or deleted so far; counted, for Count
+        uint32_t bytes = 0;    // Count: their total size
+        std::string path;      // what it was about
+        uint32_t ms = 0;       // how long it took, once it has ended
+    };
+
+    FileOps(StorageService& storage, InUse inUse);
+
+    // Each returns "" when the operation started, or why it can't. One at a time.
+    std::string list(const std::string& folder);
+    std::string count(const std::string& path);
+    std::string copy(const std::string& from, bool folder, const std::string& intoFolder, const std::string& name, bool replace = false);
+    std::string move(const std::string& from, bool folder, const std::string& to, bool replace = false);
+    std::string remove(const std::string& path, bool folder);
+    std::string makeFolder(const std::string& path);
+    void cancel() { cancel_ = true; }
+    // Why `path` can't be renamed, moved or deleted, or "": asked before the confirmation.
+    std::string whyReadOnly(const std::string& path, bool folder) const;
+
+    bool busy() const { return busy_; }
+    Status status() const;        // while it runs
+    bool finished(Status& out);   // true once, when it has ended
+    void takeListing(files::FileList& out);  // after a List finished without error
+
+    // For the console, which has no listing to know from: is `path` a folder? Waits for the card.
+    bool isFolder(const std::string& path, bool& exists);
+
+   private:
+    static constexpr uint32_t kSliceMs = 150;
+    static constexpr size_t kPiece = 4096;  // Q133
+
+    std::string start(Op op, const std::string& path);
+    void queue();
+    void slice();              // on the storage task
+    bool sliceList();          // each: true when the operation is over
+    bool sliceCount();
+    bool sliceCopy();
+    bool sliceDelete();
+    void fail(const std::string& why);
+    void finish();
+    bool enter(const std::string& path);  // push a folder onto the walk
+    void closeAll();
+
+    StorageService& storage_;
+    InUse inUse_;
+    mutable SemaphoreHandle_t lock_;  // status_, listing_
+    Status status_;
+    files::FileList listing_;
+    std::atomic<bool> busy_{false}, done_{false}, cancel_{false};
+    std::atomic<uint32_t> doneBytes_{0}, files_{0};
+
+    // The operation in hand: only the storage task touches these while it runs.
+    Op op_ = Op::None;
+    std::string from_, to_;
+    bool replace_ = false, sourceIsFolder_ = false, undo_ = false;
+    int phase_ = 0;
+    std::vector<fs::File> dirs_;       // the folders being walked, outermost first
+    std::vector<std::string> paths_;   // their paths
+    FF_DIR listDir_;                   // List reads the folder straight from FatFs
+    bool listOpen_ = false;
+    fs::File in_, out_;                // the file being copied
+    std::string outPath_;
+    uint32_t countBytes_ = 0, startMs_ = 0;
+    uint32_t fileBytes_ = 0, fileSize_ = 0;  // copied of the file in hand; its size when opened
+};
+
+}  // namespace roro
@@ -12,6 +12,7 @@
 #include "gemtext.h"
 #include "platform/console.h"
 #include "sha256.h"
+#include "platform/counted_client.h"
 #include "storage_paths.h"

 namespace roro {
@@ -544,7 +545,7 @@ void GeminiService::fetchOne(const std::string& url, GeminiPage& page, bool load
    auto track = [this]() { lowest_ = std::min<size_t>(lowest_, esp_get_free_heap_size()); };

    size_t freeBefore = esp_get_free_heap_size();  // what's left once the connection closes again
-    NetworkClientSecure tls;
+    Counted<NetworkClientSecure> tls(net::User::Gemini);
    tls.setInsecure();  // trust on first use: the pinned fingerprint is what counts (Q71)
    tls.setTimeout(15);
    if (!tls.connect(u.host.c_str(), u.portOrDefault())) {
@@ -0,0 +1,137 @@
+#include "services/gitea_releases.h"
+
+#include <memory>
+
+#include "platform/https_get.h"
+#include "update_check.h"
+
+namespace roro {
+
+namespace {
+struct Guard {
+    explicit Guard(SemaphoreHandle_t l) : l_(l) { xSemaphoreTake(l_, portMAX_DELAY); }
+    ~Guard() { xSemaphoreGive(l_); }
+    SemaphoreHandle_t l_;
+};
+
+std::string api(const std::string& what) { return std::string("/api/v1/repos/") + release::kGiteaRepo + "/releases" + what; }
+}  // namespace
+
+bool GiteaReleases::fetch(const std::string& path, size_t max, std::vector<release::Release>& out) {
+    HttpsGet get(net::User::Updates);
+    std::string why = get.open(release::kGiteaHost, path, "application/json");
+    if (!why.empty()) {
+        finish(false, why);
+        return false;
+    }
+    release::ReleaseReader reader(max);
+    std::unique_ptr<uint8_t[]> buf(new (std::nothrow) uint8_t[512]);
+    if (!buf) {
+        finish(false, "Not enough memory");
+        return false;
+    }
+    for (;;) {
+        int n = get.read(buf.get(), 512);
+        if (n < 0) {
+            finish(false, "The connection broke off");
+            return false;
+        }
+        if (n == 0) break;
+        reader.feed(reinterpret_cast<const char*>(buf.get()), n);
+        if (!reader.ok()) break;
+    }
+    reader.end();
+    if (!reader.ok() || !reader.complete()) {
+        finish(false, "Gitea's answer isn't what was expected");
+        return false;
+    }
+    out = reader.releases();
+    return true;
+}
+
+void GiteaReleases::finish(bool ok, const std::string& error) {
+    Guard g(lock_);
+    status_ = ok ? Status::Done : Status::Failed;
+    error_ = error;
+    seq_++;
+}
+
+bool GiteaReleases::fetchLatest() {
+    {
+        Guard g(lock_);
+        status_ = Status::Busy;
+        error_.clear();
+    }
+    std::vector<release::Release> got;
+    if (!fetch(api("/latest"), 1, got)) return false;
+    if (got.empty() || !got[0].usable()) {
+        finish(false, "No release to install on the server");
+        return false;
+    }
+    {
+        Guard g(lock_);
+        latest_ = got[0];
+        haveLatest_ = true;
+    }
+    finish(true, "");
+    return true;
+}
+
+bool GiteaReleases::fetchList() {
+    {
+        Guard g(lock_);
+        status_ = Status::Busy;
+        error_.clear();
+    }
+    std::vector<release::Release> got;
+    if (!fetch(api("?limit=" + std::to_string(kListSize) + "&draft=false&pre-release=false"), kListSize, got)) return false;
+    std::vector<release::Release> usable;
+    for (auto& r : got)
+        if (r.usable()) usable.push_back(std::move(r));
+    {
+        Guard g(lock_);
+        list_ = std::move(usable);
+        if (!list_.empty() && (!haveLatest_ || release::versionNewer(list_[0].tag, latest_.tag))) {
+            latest_ = list_[0];
+            haveLatest_ = true;
+        }
+    }
+    finish(true, "");
+    return true;
+}
+
+GiteaReleases::Status GiteaReleases::status() const {
+    Guard g(lock_);
+    return status_;
+}
+
+std::string GiteaReleases::error() const {
+    Guard g(lock_);
+    return error_;
+}
+
+uint32_t GiteaReleases::seq() const {
+    Guard g(lock_);
+    return seq_;
+}
+
+bool GiteaReleases::latest(release::Release& out) const {
+    Guard g(lock_);
+    if (haveLatest_) out = latest_;
+    return haveLatest_;
+}
+
+std::vector<release::Release> GiteaReleases::list() const {
+    Guard g(lock_);
+    return list_;
+}
+
+bool GiteaReleases::find(const std::string& tag, release::Release& out) const {
+    Guard g(lock_);
+    for (const auto& r : list_)
+        if (r.tag == tag) return out = r, true;
+    if (haveLatest_ && latest_.tag == tag) return out = latest_, true;
+    return false;
+}
+
+}  // namespace roro
@@ -0,0 +1,48 @@
+#pragma once
+
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+
+#include <string>
+#include <vector>
+
+#include "release_info.h"
+
+namespace roro {
+
+// What the device knows of the project's releases on Gitea (docs/milestones/R1.md, #6): the latest,
+// and a list of the last ten. The fetching runs on the Update Service's task; the screens read what
+// came out, from the main loop.
+class GiteaReleases {
+   public:
+    enum class Status : uint8_t { Never, Busy, Done, Failed };
+    static constexpr size_t kListSize = 10;
+
+    GiteaReleases() : lock_(xSemaphoreCreateMutex()) {}
+
+    // On the Update Service's task. True when the answer was read; otherwise error() says why.
+    bool fetchLatest();
+    bool fetchList();
+
+    void fail(const std::string& error) { finish(false, error); }  // something stopped it before it began
+    Status status() const;
+    std::string error() const;
+    uint32_t seq() const;  // grows with every answer that changed something
+    bool latest(release::Release& out) const;          // false: not fetched yet
+    std::vector<release::Release> list() const;
+    bool find(const std::string& tag, release::Release& out) const;  // in the list, or the latest
+
+   private:
+    bool fetch(const std::string& path, size_t max, std::vector<release::Release>& out);
+    void finish(bool ok, const std::string& error);
+
+    mutable SemaphoreHandle_t lock_;
+    Status status_ = Status::Never;
+    std::string error_;
+    uint32_t seq_ = 0;
+    bool haveLatest_ = false;
+    release::Release latest_;
+    std::vector<release::Release> list_;
+};
+
+}  // namespace roro
@@ -66,7 +66,7 @@ void GnssService::close() {

 void GnssService::tick(uint32_t nowMs) {
    if (!open_) open(nowMs);
-    bool wanted = settings_.getBool(Setting::GnssEnabled);
+    bool wanted = settings_.getBool(Setting::GnssEnabled) && !held_;
    if (wanted && !active_) wake(nowMs);
    if (!wanted && (active_ || !standbyMs_ || nowMs - standbyMs_ >= kStandbyRenewMs)) standby(nowMs);

@@ -35,6 +35,10 @@ class GnssService : public Service {
    void tick(uint32_t nowMs) override;

    bool on() const { return active_; }
+    // Standby while the LoRa radio listens, when the user chose that (issue #20): the receiver
+    // raises the radio's noise floor by 8 dB while it runs. Never asked for during a Track.
+    void holdForLora(bool hold) { held_ = hold; }
+    bool heldForLora() const { return held_ && !active_; }
    bool receiving(uint32_t nowMs) const { return active_ && lastLineMs_ && nowMs - lastLineMs_ < kSilentAfterMs; }
    const gnss::GnssState& state() const { return parser_.state(); }
    uint32_t onSinceMs() const { return openedMs_; }  // when the receiver was last woken
@@ -49,6 +53,7 @@ class GnssService : public Service {
    std::string startTrack(uint32_t nowMs);
    void stopTrack();
    bool tracking() const { return !trackPath_.empty(); }
+    const std::string& trackPath() const { return trackPath_; }
    int trackPoints() const { return trackPoints_; }
    uint32_t trackStartMs() const { return trackStartMs_; }

@@ -71,7 +76,7 @@ class GnssService : public Service {
    StorageService& storage_;
    EventBus& bus_;
    gnss::NmeaParser parser_;
-    bool open_ = false, active_ = false, echo_ = false;
+    bool open_ = false, active_ = false, echo_ = false, held_ = false;
    uint32_t bytes_ = 0, standbyMs_ = 0;
    uint32_t openedMs_ = 0, lastLineMs_ = 0, firstFixMs_ = 0, clockSetMs_ = 0;
    gnss::FixType lastFix_ = gnss::FixType::None;
@@ -224,6 +224,14 @@ void IrcService::loop() {
        if (!wanted_) {
            if (open_) close("disconnected");
            status_ = Status::Stopped;
+        } else if (held_) {
+            if (open_) {
+                conn_->print("QUIT :updating\r\n");
+                vTaskDelay(pdMS_TO_TICKS(300));
+                close("paused while the device updates");
+            }
+            status_ = Status::Paused;
+            retryAtMs_ = now;  // back at once when released
        } else if (!wifiUp) {
            if (open_) close(monitoring ? "paused for Wi-Fi monitoring" : "Wi-Fi lost");
            status_ = monitoring ? Status::Paused : Status::WaitingForWifi;
@@ -1,6 +1,7 @@
 #pragma once

 #include <NetworkClientSecure.h>
+#include "platform/counted_client.h"
 #include <freertos/FreeRTOS.h>
 #include <freertos/semphr.h>

@@ -37,6 +38,11 @@ class IrcService : public Service {
    void disconnect();
    bool running() const { return wanted_; }
    bool stoppedByUser() const { return stoppedByUser_; }
+
+    // A TLS connection to Gitea needs more memory than is left beside this one (#6, Q172): the
+    // Update Service asks IRC to step aside while it talks to the server, and to come back after.
+    // Unlike disconnect(), nothing is remembered as "stopped by the user".
+    void holdForUpdate(bool hold) { held_ = hold; }
    Status status() const { return status_; }

    // Read or act on the session while holding its lock: withSession([](IrcSession& s) { ... }).
@@ -75,8 +81,8 @@ class IrcService : public Service {
    std::unique_ptr<IrcSession> session_;
    SemaphoreHandle_t lock_ = nullptr;
    TaskHandle_t task_ = nullptr;
-    NetworkClientSecure tlsClient_;
-    NetworkClient plainClient_;
+    Counted<NetworkClientSecure> tlsClient_{net::User::Irc};  // counted for the System App (S1, Q121)
+    Counted<NetworkClient> plainClient_{net::User::Irc};
    NetworkClient* conn_ = &tlsClient_;  // whichever the config asks for
    ReconnectPolicy backoff_;
    std::string partial_;
@@ -85,6 +91,7 @@ class IrcService : public Service {
    volatile bool stopRequested_ = false;
    bool quitSent_ = false;  // /quit already queued its QUIT
    volatile bool restart_ = false;
+    volatile bool held_ = false;  // stepping aside for an update
    volatile Status status_ = Status::Stopped;
    bool open_ = false;
    uint32_t retryAtMs_ = 0;
@@ -0,0 +1,110 @@
+#ifdef RORO_DEBUG
+
+#include "services/noise_test.h"
+
+#include <Arduino.h>
+
+#include <algorithm>
+#include <cstdio>
+
+#include "platform/console.h"
+#include "sweep_view.h"
+
+namespace roro {
+
+void NoiseTest::start(std::vector<Condition> conditions, int passes) {
+    if (running()) return;
+    conditions_ = std::move(conditions);
+    results_.clear();
+    report_.clear();
+    passes_ = passes;
+    index_ = 0;
+    console.printf("noise test: %u conditions, %d passes each\n", (unsigned)conditions_.size(), passes_);
+    begin(millis());
+}
+
+void NoiseTest::begin(uint32_t nowMs) {
+    const Condition& c = conditions_[index_];
+    if (c.apply) c.apply();
+    radio_.sweep(true);  // sets the radio up again, with whatever the condition changed
+    std::fill(std::begin(lowest_), std::end(lowest_), 0);
+    std::fill(std::begin(counts_), std::end(counts_), 0);
+    seen_ = 0;
+    phase_ = Phase::Settle;
+    phaseMs_ = nowMs;
+}
+
+void NoiseTest::step(uint32_t nowMs) {
+    if (phase_ == Phase::Idle) return;
+    const Condition& c = conditions_[index_];
+    if (phase_ == Phase::Settle) {
+        if (nowMs - phaseMs_ < c.settleMs) return;
+        lastSeq_ = radio_.sweeps();
+        phase_ = Phase::Sweep;
+        phaseMs_ = nowMs;
+        return;
+    }
+    SweepFrame f;
+    if (radio_.sweeps() != lastSeq_ && radio_.sweepFrame(f)) {
+        lastSeq_ = f.seq;
+        fromHz_ = f.fromHz, stepHz_ = f.stepHz, steps_ = f.steps;
+        for (uint16_t i = 0; i < f.steps; i++) {
+            lowest_[i] = seen_ ? std::min(lowest_[i], f.dbm[i]) : f.dbm[i];
+            counts_[std::clamp<int>(-f.dbm[i], 0, 127)]++;
+        }
+        seen_++;
+    }
+    bool stuck = nowMs - phaseMs_ > 20000;  // the radio never swept: don't hang the test
+    if (seen_ < passes_ && !stuck) return;
+
+    Result r;
+    r.name = c.name;
+    if (seen_) {
+        // The floor: the median of every reading. The top and the peaks: from the lowest reading
+        // at each step, so a burst in one pass doesn't count and a steady carrier does.
+        uint32_t total = 0, half = static_cast<uint32_t>(seen_) * steps_ / 2;
+        for (int level = 127; level >= 0; level--) {
+            total += counts_[level];
+            if (total > half) {
+                r.floor = -level;
+                break;
+            }
+        }
+        lora::SweepStats st = lora::summarize(lowest_, steps_, fromHz_, stepHz_);
+        r.top = st.top;
+        char p[32];
+        for (auto& peak : st.peaks) {
+            std::snprintf(p, sizeof p, "%s%.1f %d", r.peaks.empty() ? "" : ", ", peak.hz / 1e6, peak.dbm);
+            r.peaks += p;
+        }
+    } else {
+        r.name += " (no sweep)";
+    }
+    results_.push_back(r);
+    radio_.sweep(false);
+    if (c.restore) c.restore();
+    if (++index_ < conditions_.size()) begin(nowMs);
+    else finish();
+}
+
+void NoiseTest::finish() {
+    phase_ = Phase::Idle;
+    char line[160];
+    report_.push_back("noise test: floor = median of every reading; top and peaks = steady (lowest of the passes), dBm at 125 kHz");
+    for (auto& r : results_) {
+        std::snprintf(line, sizeof line, "noise test: %-26s floor %4d  top %4d  %s", r.name.c_str(), r.floor, r.top,
+                      r.peaks.empty() ? "no steady peak" : r.peaks.c_str());
+        report_.push_back(line);
+    }
+    report_.push_back("noise test: done");
+    printReport(console);
+}
+
+void NoiseTest::printReport(Print& out) const {
+    if (report_.empty()) return (void)out.println(running() ? "noise test: still running" : "noise test: none run yet");
+    for (auto& l : report_) out.println(l.c_str());
+}
+
+}  // namespace roro
+
+#endif  // RORO_DEBUG
@@ -0,0 +1,59 @@
+#pragma once
+
+#ifdef RORO_DEBUG
+
+#include <Print.h>
+
+#include <functional>
+#include <string>
+#include <vector>
+
+#include "services/radio_service.h"
+
+namespace roro {
+
+// `lora noise test` (Debug Builds, issue #20): which part of the Cardputer raises the radio's
+// noise floor? Applies one condition at a time, Sweeps the band a few passes, records the floor
+// and the steady peaks, and puts things back. It runs from the main loop on its own, because one
+// condition switches Wi-Fi off, and prints its report once the console can be reached again.
+class NoiseTest {
+   public:
+    struct Condition {
+        std::string name;
+        std::function<void()> apply, restore;  // either may be empty
+        uint32_t settleMs = 1500;
+    };
+
+    explicit NoiseTest(RadioService& radio) : radio_(radio) {}
+    void start(std::vector<Condition> conditions, int passes = 8);
+    void step(uint32_t nowMs);  // from the main loop
+    bool running() const { return phase_ != Phase::Idle; }
+    void printReport(Print& out) const;
+
+   private:
+    enum class Phase { Idle, Settle, Sweep };
+    struct Result {
+        std::string name;
+        int floor = 0, top = 0;
+        std::string peaks;  // steady ones: the lowest reading at each step over the passes
+    };
+    void begin(uint32_t nowMs);
+    void finish();
+
+    RadioService& radio_;
+    std::vector<Condition> conditions_;
+    std::vector<Result> results_;
+    size_t index_ = 0;
+    int passes_ = 8, seen_ = 0;
+    Phase phase_ = Phase::Idle;
+    uint32_t phaseMs_ = 0, lastSeq_ = 0;
+    int8_t lowest_[SweepFrame::kMaxSteps];
+    uint16_t counts_[128];  // how often each level (in -dBm) was read: for the median
+    uint32_t fromHz_ = 0, stepHz_ = 0;
+    uint16_t steps_ = 0;
+    std::vector<std::string> report_;
+};
+
+}  // namespace roro
+
+#endif  // RORO_DEBUG
@@ -42,6 +42,7 @@ void PowerService::applyScreen(ScreenState state) {
 }

 void PowerService::powerOff() {
+    if (beforePowerOff) beforePowerOff();
    auto& display = M5Cardputer.Display;
    display.wakeup();
    display.setBrightness(settings_.getInt(Setting::Brightness) * 255 / 100);
@@ -1,5 +1,7 @@
 #pragma once

+#include <functional>
+
 #include "power_policy.h"
 #include "service.h"
 #include "settings.h"
@@ -24,6 +26,9 @@ class PowerService : public Service {

    ScreenState screen() const { return applied_; }

+    // Run before the device powers off: the last chance to put on the card what's only in memory.
+    std::function<void()> beforePowerOff;
+
   private:
    void applyScreen(ScreenState state);
    void powerOff();
@@ -71,19 +71,19 @@ bool RadioService::beginRadio(Print* report) {
    Config c = config();
    float mhz = c.frequencyHz / 1e6f;
    int16_t state = radio_->begin(mhz, c.bandwidthKHz, c.spreadingFactor, c.codingRate, c.syncWord, 0, c.preamble,
-                                  tcxo_, false);
+                                  tcxo_, ldo_);
    if (state != RADIOLIB_ERR_NONE && tcxo_ > 0) {  // Meshtastic's TCXO_OPTIONAL: fall back to the crystal
        if (report) report->printf("lora probe: begin with TCXO %.1f V: error %d, trying the crystal\n", tcxo_, state);
        tcxo_ = 0;
        state = radio_->begin(mhz, c.bandwidthKHz, c.spreadingFactor, c.codingRate, c.syncWord, 0, c.preamble, tcxo_,
-                              false);
+                              ldo_);
    }
    if (state != RADIOLIB_ERR_NONE) {
        if (report) report->printf("lora probe: error %d, no SX1262 found\n", state);
        return false;
    }
    radio_->setDio2AsRfSwitch(true);       // DIO2 selects TX or RX in the switch, as in Meshtastic
-    radio_->setRxBoostedGainMode(true);    // about 2 dB more sensitivity for about 2 mA
+    radio_->setRxBoostedGainMode(boostedGain_);  // about 2 dB more sensitivity for about 2 mA
    return true;
 }

@@ -191,6 +191,12 @@ void RadioService::store(RadioPacket& p) {
 }

 #ifdef RORO_DEBUG
+void RadioService::debugAntenna(bool on) {
+    auto& i2c = M5.In_I2C;
+    uint8_t out = i2c.readRegister8(kExpander, kOutput, kI2cFreq);
+    i2c.writeRegister8(kExpander, kOutput, on ? (out | 1) : (out & ~1), kI2cFreq);
+}
+
 void RadioService::inject(const uint8_t* data, size_t len, float rssi, float snr) {
    if (!listening_) return (void)console.println("lora inject: not listening");
    RadioPacket p;
@@ -100,6 +100,15 @@ class RadioService : public Service {
    void setEcho(bool echo);
    void probe(Print& out);  // `lora probe`: runs on the radio task
 #ifdef RORO_DEBUG
+    // For the noise self-test (issue #20): the chip's regulator as an LDO instead of its DC-DC
+    // converter, and receive gain boosted or not. Used the next time the radio is set up.
+    void debugOptions(bool ldo, bool boostedGain) {
+        ldo_ = ldo;
+        boostedGain_ = boostedGain;
+    }
+    // The antenna switch (the Cap's expander, P0), for the reference "what the chip hears alone".
+    // From the main loop only, which owns the I2C bus.
+    void debugAntenna(bool on);
    // `lora inject`: a packet into the ring as if received, to test the App and Captures with no
    // transmitter in range. Nothing goes on air.
    void inject(const uint8_t* data, size_t len, float rssi, float snr);
@@ -132,6 +141,7 @@ class RadioService : public Service {
    Config config_;
    bool present_ = false, expander_ = false;
    float tcxo_ = 1.8f;
+    std::atomic<bool> ldo_{false}, boostedGain_{true};
    std::atomic<uint8_t> clients_{0};
    std::atomic<bool> listening_{false}, configChanged_{false}, probeWanted_{false}, echo_{false};
    std::atomic<uint32_t> seq_{0}, packets_{0}, crcErrors_{0}, radioErrors_{0}, restarts_{0};
@@ -1,4 +1,5 @@
 #include "update_service.h"
+#include "platform/counted_client.h"

 #include <SD.h>
 #include <WiFi.h>
@@ -6,6 +7,10 @@

 #include <memory>

+#include <ctime>
+
+#include "http_head.h"
+#include "platform/https_get.h"
 #include "platform/ota_device.h"
 #include "platform/system_info.h"
 #include "probation.h"
@@ -59,6 +64,25 @@ class FileSource : public UpdateSource {
    File& f_;
 };

+// A release being downloaded from Gitea: the same bytes a push or a card would give.
+class GiteaSource : public UpdateSource {
+   public:
+    GiteaSource(HttpsGet& get, long cutAfter, long flipAt) : get_(get), cut_(cutAfter), flip_(flipAt) {}
+    int read(uint8_t* buf, size_t len) override {
+        if (cut_ >= 0 && pos_ >= cut_) return -1;  // Debug Builds: the connection "breaks" here
+        int n = get_.read(buf, len);
+        if (n > 0 && flip_ >= pos_ && flip_ < pos_ + n) buf[flip_ - pos_] ^= 1;  // and a byte "arrives wrong"
+        if (n > 0) pos_ += n;
+        return n;
+    }
+
+   private:
+    HttpsGet& get_;
+    long cut_, flip_, pos_ = 0;
+};
+
+constexpr time_t kClockSetAfter = 1700000000;  // anything earlier is the clock's default
+
 }  // namespace

 UpdateService::UpdateService(KeyValueStore& store, WifiService& wifi, SavedNetworks& saved, StorageService& storage,
@@ -84,10 +108,11 @@ void UpdateService::start() {
    store_.getString("ota_from", from);
    if (!pending.empty() && pending != versionString()) {
        notify("Update to " + pending + " failed, back on " + versionString(), NotificationLevel::Warning);
+        store_.putString("ota_failed", pending);  // not announced again until there's a newer one (Q168)
        store_.putString("ota_pending", "");
    }

-    if (!task_) xTaskCreate(taskEntry, "update", 5120, this, 1, &task_);  // peak 3.4 KB (ECDSA check, M2)
+    if (!task_) xTaskCreate(taskEntry, "update", 7168, this, 1, &task_);  // peak 5.4 KB: TLS to Gitea and the signature check (#6)
 }

 void UpdateService::bootGuard(KeyValueStore& store) {
@@ -105,6 +130,7 @@ void UpdateService::bootGuard(KeyValueStore& store) {
 }

 void UpdateService::tick(uint32_t nowMs) {
+    scheduleDailyCheck(nowMs);
    if (!probation_) return;
    bool wifiConfigured = settings_.getBool(Setting::WifiEnabled) && saved_.count() > 0;
    bool wifiUp = wifi_.state() == WifiController::State::Connected;
@@ -183,6 +209,134 @@ void UpdateService::installFromSd(const std::string& path) {
    });
 }

+std::string UpdateService::failedVersion() const {
+    std::string failed;
+    store_.getString("ota_failed", failed);
+    return failed;
+}
+
+std::string UpdateService::requestInstall(const std::string& tag, bool force) {
+    if (phase_ != Phase::Idle || giteaBusy()) return "Busy with something else";
+    if (!force && release::isDebugBuild(runningVersion())) return "A Debug Build keeps its console: update it from your PC";
+    if (wifi_.state() != WifiController::State::Connected) return "No Wi-Fi";
+    release::Release r;
+    if (!gitea_.find(tag, r)) return "Look for releases first";
+    if (!release::trustedAssetUrl(r.otaUrl)) return "That download isn't on the project's server";
+    installTag_ = tag;
+    request_ = Request::Install;
+    return "";
+}
+
+// Once a day while Wi-Fi is up and the Clock is set (Q165). Skipped, and tried again later, when
+// something else is going on or memory is short; never during Probation or an install.
+void UpdateService::scheduleDailyCheck(uint32_t nowMs) {
+    if (!dailyCheck_ || !settings_.getBool(Setting::CheckUpdates)) return;
+    if (static_cast<int32_t>(nowMs - nextCheckMs_) < 0 || probation_ || phase_ != Phase::Idle || giteaBusy()) return;
+    if (wifi_.state() != WifiController::State::Connected) return;
+    time_t now = time(nullptr);
+    if (now < kClockSetAfter) return;
+    int32_t today = static_cast<int32_t>(now / 86400), last = 0;
+    store_.getInt("rel_day", last);
+    if (today == last) {
+        nextCheckMs_ = nowMs + 3600000;  // look again in an hour, in case the day has turned
+        return;
+    }
+    // Never at IRC's expense: with IRC connected there isn't the room (Q172), so this waits.
+    if (esp_get_free_heap_size() < HttpsGet::kNeedFree) {
+        nextCheckMs_ = nowMs + 600000;
+        return;
+    }
+    nextCheckMs_ = nowMs + 1800000;  // if this one fails
+    request_ = Request::BackgroundCheck;
+}
+
+// What a person asked for (a check, a list, an install) may take IRC offline for a few seconds:
+// a TLS connection needs about 80 KB and IRC's own holds 40 KB of what there is (R1, Q172).
+bool UpdateService::makeRoom() {
+    if (esp_get_free_heap_size() >= HttpsGet::kNeedFree) return true;
+    if (!holdMemory) return false;
+    held_ = true;
+    holdMemory(true);
+    for (int i = 0; i < 40 && esp_get_free_heap_size() < HttpsGet::kNeedFree; i++) delay(100);  // its TLS session goes
+    return esp_get_free_heap_size() >= HttpsGet::kNeedFree;
+}
+
+void UpdateService::serve() {
+    Request r = request_;
+    if (r == Request::None) return;
+    request_ = Request::None;
+    serving_ = true;
+    held_ = false;
+    if (r != Request::BackgroundCheck && r != Request::None) {
+        bool ok = makeRoom();
+        if (!ok) {
+            gitea_.fail("Not enough memory: close a Gemini page");
+            if (r == Request::Install) notify("Update refused: not enough memory", NotificationLevel::Warning);
+            r = Request::None;
+        }
+    }
+    switch (r) {
+        case Request::Check:
+        case Request::BackgroundCheck: {
+            if (!gitea_.fetchLatest()) break;
+            time_t now = time(nullptr);
+            if (now >= kClockSetAfter) store_.putInt("rel_day", static_cast<int32_t>(now / 86400));
+            release::Release latest;
+            if (r == Request::BackgroundCheck && gitea_.latest(latest) &&
+                release::shouldAnnounce(latest, runningVersion(), failedVersion(), announced_)) {
+                announced_ = latest.tag;
+                notify(latest.tag + " is out: see Settings > Firmware", NotificationLevel::Info);  // 48 bytes at most
+            }
+            break;
+        }
+        case Request::List: gitea_.fetchList(); break;
+        case Request::Install: {
+            release::Release release;
+            if (gitea_.find(installTag_, release)) installFromGitea(release);
+            break;
+        }
+#ifdef RORO_DEBUG
+        case Request::Probe: {
+            HttpsGet get(net::User::Updates);
+            std::string why = get.open(probeHost_, probePath_, "*/*");
+            probeResult_ = why.empty() ? "accepted, the server answered 200" : why;
+            break;
+        }
+#endif
+        case Request::None: break;
+    }
+    // A check or a list someone asked for that failed says so; the daily one stays quiet.
+    if ((r == Request::Check || r == Request::List) && gitea_.status() == GiteaReleases::Status::Failed)
+        notify(gitea_.error(), NotificationLevel::Warning);
+    // IRC comes back, unless the device is about to restart into an update.
+    if (held_ && phase_ != Phase::Installed && holdMemory) holdMemory(false);
+    held_ = false;
+    serving_ = false;
+}
+
+void UpdateService::installFromGitea(const release::Release& r) {
+    release::Url url = release::parseUrl(r.otaUrl);
+    incoming_ = r.tag;
+    percent_ = 0;
+    phase_ = Phase::Receiving;
+    HttpsGet get(net::User::Updates);
+    std::string why = get.open(url.host, url.path, "application/octet-stream");
+    if (why.empty() && r.otaSize && get.contentLength() >= 0 && static_cast<uint32_t>(get.contentLength()) != r.otaSize)
+        why = "The file isn't the size the server listed";
+    if (!why.empty()) {
+        phase_ = Phase::Idle;
+        notify("Update refused: " + why, NotificationLevel::Warning);
+        return;
+    }
+#ifdef RORO_DEBUG
+    GiteaSource source(get, damageCut_, damageFlip_);
+    damageCut_ = damageFlip_ = -1;
+#else
+    GiteaSource source(get, -1, -1);
+#endif
+    install(source, "Gitea");
+}
+
 void UpdateService::taskEntry(void* self) { static_cast<UpdateService*>(self)->listen(); }

 void UpdateService::listen() {
@@ -207,8 +361,9 @@ void UpdateService::listen() {
                esp_restart();
            }
        }
+        if (phase_ == Phase::Idle) serve();
        if (listening && phase_ == Phase::Idle) {
-            NetworkClient client = server.accept();
+            Counted<NetworkClient> client(server.accept(), net::User::Updates);
            if (client) {
                client.setNoDelay(true);
                NetSource src(client);
@@ -2,11 +2,16 @@

 #include <freertos/FreeRTOS.h>

+#include <functional>
 #include <string>

+#include "update_check.h"
+#include "version.h"
+
 #include "event_bus.h"
 #include "key_value_store.h"
 #include "service.h"
+#include "services/gitea_releases.h"
 #include "services/storage_service.h"
 #include "services/wifi_service.h"

@@ -39,12 +44,46 @@ class UpdateService : public Service {
    // Installs an Update File from the SD card (runs on the storage task).
    void installFromSd(const std::string& path);

+    // Updates from Gitea (docs/milestones/R1.md, #6). The requests are done on this Service's task;
+    // the answers are read from gitea().
+    GiteaReleases& gitea() { return gitea_; }
+    void requestCheck() { request_ = Request::Check; }
+    void requestList() { request_ = Request::List; }
+    // Downloads `tag` (a release known from the last check or list) into the inactive slot and
+    // installs it. "" when it started, or why not. A Debug Build doesn't install a release (Q171,
+    // it would take its Debug Console away) unless `force`, which only the Debug Console passes.
+    std::string requestInstall(const std::string& tag, bool force = false);
+    bool giteaBusy() const { return request_ != Request::None || serving_; }
+    // Asked to make room for a TLS connection (R1, Q172): IRC steps aside while the Update Service
+    // talks to Gitea. Set by the main loop; `true` to step aside, `false` to come back.
+    std::function<void(bool)> holdMemory;
+    // The daily check (Q165) only runs once the main loop says it may: not in Safe Mode.
+    void enableDailyCheck() { dailyCheck_ = true; }
+    // The version that counts as running for comparisons: a Debug Build can pretend to be older.
+    std::string runningVersion() const { return fakeVersion_.empty() ? versionString() : fakeVersion_; }
+    void pretendVersion(const std::string& v) { fakeVersion_ = v; }
+    std::string failedVersion() const;  // a release that rolled back here, "" if none
+#ifdef RORO_DEBUG
+    // Debug Builds only, to try the refusals on the real network path: one HTTPS GET to any host
+    // (is its certificate accepted?), and a download cut short or with one byte flipped.
+    void requestProbe(const std::string& host, const std::string& path) { probeHost_ = host; probePath_ = path; probeResult_ = "..."; request_ = Request::Probe; }
+    std::string probeResult() const { return probeResult_; }
+    void damageNextDownload(long cutAfter, long flipAt) { damageCut_ = cutAfter; damageFlip_ = flipAt; }
+    void forgetToday() { store_.putInt("rel_day", 0); nextCheckMs_ = 0; announced_.clear(); }  // the daily check runs at the next tick
+#endif
+
    // The main loop calls this once it has drawn a frame (part of Probation).
    void firstFrameDrawn() { firstFrame_ = true; }
    // True when an installed update is waiting to reboot; the main loop reboots when it's safe.
    bool rebootPending() const { return phase_ == Phase::Installed; }

   private:
+    enum class Request : uint8_t { None, Check, BackgroundCheck, List, Install, Probe };
+
+    void serve();                       // on this task: one request
+    bool makeRoom();                    // true when a TLS connection can start; may have asked holdMemory
+    void installFromGitea(const release::Release& release);
+    void scheduleDailyCheck(uint32_t nowMs);  // from tick()
    static void taskEntry(void* self);
    void listen();
    void install(class UpdateSource& source, const char* via);
@@ -62,6 +101,19 @@ class UpdateService : public Service {
    std::string incoming_;
    bool probation_ = false;
    volatile bool firstFrame_ = false;
+
+    GiteaReleases gitea_;
+    volatile Request request_ = Request::None;
+    volatile bool serving_ = false;
+    bool held_ = false;  // IRC was asked to step aside, on this task
+    std::string installTag_, fakeVersion_, announced_;
+    bool dailyCheck_ = false;
+    uint32_t nextCheckMs_ = 90000;  // not before the device has settled
+#ifdef RORO_DEBUG
+    std::string probeHost_, probePath_;
+    volatile long damageCut_ = -1, damageFlip_ = -1;
+    std::string probeResult_;
+#endif
 };

 }  // namespace roro
@@ -87,7 +87,10 @@ void WifiService::applyServers(Why why) {
            touched = true;
        }
    }
-    if (!esp_sntp_enabled()) {
+    // Our own flag, not esp_sntp_enabled(): starting is only queued for the network task, and a
+    // second call that looked before it ran would start SNTP twice, which ESP-IDF asserts on.
+    if (!sntpStarted_) {
+        sntpStarted_ = true;
        esp_sntp_setoperatingmode(ESP_SNTP_OPMODE_POLL);
        esp_sntp_init();
    } else if (touched || changed) {
@@ -247,9 +250,12 @@ void WifiService::tick(uint32_t nowMs) {
        apply(controller_.disconnected(nowMs));
    }

-    apply(controller_.update(nowMs, settings_.getBool(Setting::WifiEnabled)));
+    apply(controller_.update(nowMs, settings_.getBool(Setting::WifiEnabled) && !paused_));

-    if (controller_.state() == State::Connected && nowMs - serversCheckedMs_ >= kServersEveryMs) applyServers(Why::Check);
+    // Signed: serversCheckedMs_ can be newer than this pass's nowMs (set from millis() just above),
+    // and the unsigned difference then ran the check again at once, at every join.
+    if (controller_.state() == State::Connected && static_cast<int32_t>(nowMs - serversCheckedMs_) >= static_cast<int32_t>(kServersEveryMs))
+        applyServers(Why::Check);

    if (ntpWaiting_ && sntp_get_sync_status() == SNTP_SYNC_STATUS_COMPLETED) {
        ntpWaiting_ = false;
@@ -56,6 +56,11 @@ class WifiService : public Service {
    void ipSettingChanged(const std::string& ssid);
    // The DNS or NTP settings changed: use them now.
    void serversChanged() { applyServers(Why::SettingsChanged); }
+#ifdef RORO_DEBUG
+    // The noise self-test switches the radio off for a few seconds. Not saved anywhere: a restart
+    // during the test brings Wi-Fi back, which a changed setting wouldn't.
+    void debugPause(bool paused) { paused_ = paused; }
+#endif

    // A Saved Network was added: try it now rather than after the retry delay.
    void savedNetworksChanged() { controller_.retryNow(millis()); }
@@ -81,7 +86,9 @@ class WifiService : public Service {
    std::vector<ScanEntry> listScan_;
    uint32_t listScanSeq_ = 0;
    bool ntpWaiting_ = false;
+    bool sntpStarted_ = false;
    bool radioInitialised_ = false;
+    bool paused_ = false;          // Debug Builds: off for a moment, whatever the setting says
    bool fixed_ = false;           // the network in use has a Fixed address
    bool dnsFromSettings_ = false;
    std::string ntpNames_[2];      // lwIP keeps the pointers, so the names live here
@@ -0,0 +1,117 @@
+#include <unity.h>
+
+#include <cstdlib>
+#include <ctime>
+#include <string>
+
+#include "file_list.h"
+
+using namespace roro::files;
+
+void setUp() {}
+void tearDown() {}
+
+void test_entries() {
+    FileList list;
+    TEST_ASSERT_EQUAL_size_t(0, list.count());
+    list.add("b.txt", 1200, 1791230400, false);
+    list.add("saved", 0, 1791230000, true);
+    TEST_ASSERT_EQUAL_size_t(2, list.count());
+    list.sort(FileSort::Name);
+    TEST_ASSERT_EQUAL_STRING("saved", list.name(0));  // folders first
+    TEST_ASSERT_TRUE(list.folder(0));
+    TEST_ASSERT_EQUAL_STRING("b.txt", list.name(1));
+    TEST_ASSERT_EQUAL_UINT32(1200, list.size(1));
+    TEST_ASSERT_EQUAL_UINT32(1791230400u, list.modified(1));
+}
+
+// Q129: folders first, then by name whatever the case; `s` cycles name, date, size.
+void test_sorting() {
+    FileList list;
+    list.add("zeta.log", 10, 300, false);
+    list.add("Alpha.log", 3000, 100, false);
+    list.add("beta.log", 200, 200, false);
+    list.add("tracks", 0, 50, true);
+    list.add("Captures", 0, 60, true);
+
+    list.sort(FileSort::Name);
+    const char* byName[] = {"Captures", "tracks", "Alpha.log", "beta.log", "zeta.log"};
+    for (int i = 0; i < 5; i++) TEST_ASSERT_EQUAL_STRING(byName[i], list.name(i));
+
+    list.sort(FileSort::Date);  // newest first, folders still first
+    const char* byDate[] = {"Captures", "tracks", "zeta.log", "beta.log", "Alpha.log"};
+    for (int i = 0; i < 5; i++) TEST_ASSERT_EQUAL_STRING(byDate[i], list.name(i));
+
+    list.sort(FileSort::Size);  // biggest first
+    const char* bySize[] = {"Captures", "tracks", "Alpha.log", "beta.log", "zeta.log"};
+    for (int i = 0; i < 5; i++) TEST_ASSERT_EQUAL_STRING(bySize[i], list.name(i));
+}
+
+// Q136: 256 entries at most. A bigger folder keeps the first 256 by name, whatever order the
+// card lists them in, and says how many more there are.
+void test_more_than_fits() {
+    FileList list;
+    char name[24];
+    for (int i = 399; i >= 0; i--) {  // the card's order: backwards
+        std::snprintf(name, sizeof name, "2026-%03d.log", i);
+        list.add(name, static_cast<uint32_t>(i), 1000 + i, false);
+    }
+    TEST_ASSERT_EQUAL_size_t(256, list.count());
+    TEST_ASSERT_EQUAL_size_t(144, list.more());
+    list.sort(FileSort::Name);
+    TEST_ASSERT_EQUAL_STRING("2026-000.log", list.name(0));
+    TEST_ASSERT_EQUAL_STRING("2026-255.log", list.name(255));
+    TEST_ASSERT_EQUAL_UINT32(255, list.size(255));
+    // And it stays small: 400 names went through, the memory is for 256.
+    TEST_ASSERT_TRUE(list.bytes() < 12 * 1024);
+}
+
+void test_folders_are_kept_before_files_when_full() {
+    FileList list;
+    char name[24];
+    for (int i = 0; i < 300; i++) {
+        std::snprintf(name, sizeof name, "a%03d.log", i);
+        list.add(name, 1, 1, false);
+    }
+    list.add("zz-folder", 0, 1, true);  // sorts first, so it's among the 256
+    list.sort(FileSort::Name);
+    TEST_ASSERT_EQUAL_STRING("zz-folder", list.name(0));
+    TEST_ASSERT_EQUAL_size_t(45, list.more());
+}
+
+void test_find_and_clear() {
+    FileList list;
+    list.add("a.txt", 1, 1, false);
+    list.add("b.txt", 2, 2, false);
+    list.sort(FileSort::Name);
+    TEST_ASSERT_EQUAL_INT(1, list.find("b.txt"));
+    TEST_ASSERT_EQUAL_INT(-1, list.find("c.txt"));
+    list.clear();
+    TEST_ASSERT_EQUAL_size_t(0, list.count());
+    TEST_ASSERT_EQUAL_size_t(0, list.more());
+}
+
+// Q129, Q137: what a row shows on the right. A date before 2020 was never set.
+void test_display() {
+    setenv("TZ", "UTC", 1);
+    tzset();
+    TEST_ASSERT_EQUAL_STRING("folder", rowDetail(true, 0, 0).c_str());
+    TEST_ASSERT_EQUAL_STRING("1.2 KB  2026-10-05", rowDetail(false, 1200, 1791230400).c_str());
+    TEST_ASSERT_EQUAL_STRING("0 B  -", rowDetail(false, 0, 315532800).c_str());  // 1980-01-01, FAT's zero
+    TEST_ASSERT_EQUAL_STRING("2026-10-05 20:00", formatStamp(1791230400).c_str());
+    TEST_ASSERT_EQUAL_STRING("-", formatStamp(0).c_str());
+    TEST_ASSERT_EQUAL_STRING("notes.txt", fitName("notes.txt", 19).c_str());
+    TEST_ASSERT_EQUAL_STRING("20261005-18..2.pcap", fitName("20261005-180932.pcap", 19).c_str());
+    TEST_ASSERT_EQUAL_INT(19, fitName("a-very-long-folder-name-without-end", 19).size());
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_entries);
+    RUN_TEST(test_sorting);
+    RUN_TEST(test_more_than_fits);
+    RUN_TEST(test_folders_are_kept_before_files_when_full);
+    RUN_TEST(test_find_and_clear);
+    RUN_TEST(test_display);
+    return UNITY_END();
+}
@@ -0,0 +1,118 @@
+#include <unity.h>
+
+#include <string>
+#include <vector>
+
+#include "file_names.h"
+
+using namespace roro::files;
+
+void setUp() {}
+void tearDown() {}
+
+void test_path_parts() {
+    TEST_ASSERT_EQUAL_STRING("/gemini/saved", parentOf("/gemini/saved/index.gmi").c_str());
+    TEST_ASSERT_EQUAL_STRING("/", parentOf("/gemini").c_str());
+    TEST_ASSERT_EQUAL_STRING("/", parentOf("/").c_str());
+    TEST_ASSERT_EQUAL_STRING("index.gmi", baseName("/gemini/saved/index.gmi").c_str());
+    TEST_ASSERT_EQUAL_STRING("", baseName("/").c_str());
+    TEST_ASSERT_EQUAL_STRING("/gemini/a.gmi", joinPath("/gemini", "a.gmi").c_str());
+    TEST_ASSERT_EQUAL_STRING("/a.gmi", joinPath("/", "a.gmi").c_str());
+    TEST_ASSERT_EQUAL_STRING("gmi", extensionOf("Index.GMI").c_str());
+    TEST_ASSERT_EQUAL_STRING("pcap", extensionOf("20261005-183340.pcap").c_str());
+    TEST_ASSERT_EQUAL_STRING("", extensionOf("README").c_str());
+    TEST_ASSERT_EQUAL_STRING("", extensionOf(".hidden").c_str());
+}
+
+void test_inside() {
+    TEST_ASSERT_TRUE(isInside("/gemini/cache/page0.gmi", "/gemini/cache"));
+    TEST_ASSERT_TRUE(isInside("/gemini/cache", "/gemini/cache"));
+    TEST_ASSERT_FALSE(isInside("/gemini/cached", "/gemini/cache"));  // a longer name isn't inside
+    TEST_ASSERT_TRUE(isInside("/irc/x.log", "/"));
+}
+
+// Q131: names typed for rename and new folder.
+void test_names_checked() {
+    TEST_ASSERT_EQUAL_STRING("", checkName("notes 2026.txt").c_str());
+    TEST_ASSERT_EQUAL_STRING("", checkName("#roro").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't be empty", checkName("").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't contain /", checkName("a/b").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't contain :", checkName("12:30.txt").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't contain ?", checkName("what?").c_str());
+    TEST_ASSERT_EQUAL_STRING("\".\" and \"..\" aren't names", checkName("..").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't end with a dot or a space", checkName("notes.").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can't end with a dot or a space", checkName("notes ").c_str());
+    TEST_ASSERT_EQUAL_STRING("A name can be 64 characters at most", checkName(std::string(65, 'a')).c_str());
+    TEST_ASSERT_EQUAL_STRING("", checkName(std::string(64, 'a')).c_str());
+}
+
+// Q130: what can't be renamed, moved or deleted, and why.
+void test_read_only() {
+    std::vector<std::string> inUse = {"/irc/irc.libera.chat/#roro/2026-10-06.log", "/gnss/tracks/20261006-071500.gpx"};
+    TEST_ASSERT_EQUAL_STRING("", whyReadOnly("/gemini/saved/a.gmi", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("", whyReadOnly("/irc/irc.libera.chat/#roro/2026-10-05.log", inUse).c_str());  // yesterday's
+    TEST_ASSERT_EQUAL_STRING("", whyReadOnly("/updates/roro9stack-v0.8.1.ota", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("", whyReadOnly("/gemini/saved", inUse).c_str());  // a folder below the top level
+
+    TEST_ASSERT_EQUAL_STRING("It's being written right now", whyReadOnly("/gnss/tracks/20261006-071500.gpx", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("It holds a file that's being written right now", whyReadOnly("/gnss/tracks", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("It holds a file that's being written right now", whyReadOnly("/irc/irc.libera.chat", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("/gemini/cache is the Gemini App's working space", whyReadOnly("/gemini/cache/page0.gmi", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("/gemini/cache is the Gemini App's working space", whyReadOnly("/gemini/cache", inUse).c_str());
+    TEST_ASSERT_EQUAL_STRING("The firmware keeps its files in /irc", whyReadOnly("/irc", {}).c_str());
+    TEST_ASSERT_EQUAL_STRING("The firmware keeps its files in /captures", whyReadOnly("/captures", {}).c_str());
+    TEST_ASSERT_EQUAL_STRING("That's the card itself", whyReadOnly("/", {}).c_str());
+    TEST_ASSERT_EQUAL_STRING("", whyReadOnly("/my stuff", {}).c_str());  // a top-level folder of the user's own
+}
+
+// Where something may be put (paste, new folder): not into the cache, not into itself.
+void test_destinations() {
+    TEST_ASSERT_EQUAL_STRING("", whyNotInto("/gemini/saved/a.gmi", "/notes").c_str());
+    TEST_ASSERT_EQUAL_STRING("", whyNotInto("/gemini/saved/a.gmi", "/").c_str());
+    TEST_ASSERT_EQUAL_STRING("/gemini/cache is the Gemini App's working space", whyNotInto("/notes/a.txt", "/gemini/cache").c_str());
+    TEST_ASSERT_EQUAL_STRING("A folder can't go inside itself", whyNotInto("/gemini/saved", "/gemini/saved/sub").c_str());
+    TEST_ASSERT_EQUAL_STRING("A folder can't go inside itself", whyNotInto("/gemini/saved", "/gemini/saved").c_str());
+    TEST_ASSERT_EQUAL_STRING("It's already there", whyNotInto("/gemini/saved/a.gmi", "/gemini/saved").c_str());
+}
+
+// A copy next to the original needs another name: "a (2).gmi".
+void test_copy_names() {
+    TEST_ASSERT_EQUAL_STRING("a (2).gmi", copyName("a.gmi", 2).c_str());
+    TEST_ASSERT_EQUAL_STRING("README (3)", copyName("README", 3).c_str());
+    TEST_ASSERT_EQUAL_STRING("archive.tar (2).gz", copyName("archive.tar.gz", 2).c_str());
+}
+
+// Q134: which viewer opens a file.
+void test_kinds() {
+    TEST_ASSERT_TRUE(kindOf("2026-10-06.log") == FileKind::Text);
+    TEST_ASSERT_TRUE(kindOf("index.gmi") == FileKind::Text);
+    TEST_ASSERT_TRUE(kindOf("2026-10-05.CSV") == FileKind::Text);
+    TEST_ASSERT_TRUE(kindOf("note.txt") == FileKind::Text);
+    TEST_ASSERT_TRUE(kindOf("20261006-071500.gpx") == FileKind::Gpx);
+    TEST_ASSERT_TRUE(kindOf("20261005-183340.pcap") == FileKind::Pcap);
+    TEST_ASSERT_TRUE(kindOf("roro9stack-v0.8.1.ota") == FileKind::Ota);
+    TEST_ASSERT_TRUE(kindOf("firmware.bin") == FileKind::Unknown);  // sniffed: text or a hex dump
+    TEST_ASSERT_TRUE(opensAtEnd("2026-10-06.log"));
+    TEST_ASSERT_FALSE(opensAtEnd("index.gmi"));
+}
+
+void test_looks_like_text() {
+    const char text[] = "line one\nline two with an \xC3\xA9\r\n\ttabbed";
+    TEST_ASSERT_TRUE(looksLikeText(reinterpret_cast<const uint8_t*>(text), sizeof text - 1));
+    const uint8_t binary[] = {0xE9, 0x05, 0x02, 0x00, 0x10, 0x00, 0x00, 0x40};
+    TEST_ASSERT_FALSE(looksLikeText(binary, sizeof binary));
+    TEST_ASSERT_TRUE(looksLikeText(nullptr, 0));  // an empty file reads as text
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_path_parts);
+    RUN_TEST(test_inside);
+    RUN_TEST(test_names_checked);
+    RUN_TEST(test_read_only);
+    RUN_TEST(test_destinations);
+    RUN_TEST(test_copy_names);
+    RUN_TEST(test_kinds);
+    RUN_TEST(test_looks_like_text);
+    return UNITY_END();
+}
@@ -0,0 +1,133 @@
+#include <unity.h>
+
+#include <cstdlib>
+#include <ctime>
+#include <string>
+#include <vector>
+
+#include "file_views.h"
+#include "loratap.h"
+#include "track.h"
+
+using namespace roro;
+using namespace roro::files;
+
+void setUp() {}
+void tearDown() {}
+
+void test_hex_row() {
+    const uint8_t d[] = {'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 0x00, 0xFF, 'x'};
+    TEST_ASSERT_EQUAL_STRING("00010 4865 6c6c 6f2c 2077  Hello, w", hexRow(0x10, d, 8).c_str());
+    TEST_ASSERT_EQUAL_STRING("00018 00ff 78              ..x", hexRow(0x18, d + 8, 3).c_str());
+    TEST_ASSERT_TRUE(hexRow(0xFFFFF, d, 8).size() <= 38);
+}
+
+// A Track as the GNSS Service writes it, fed in pieces of every size: the same summary each time.
+void test_gpx_summary() {
+    setenv("TZ", "UTC", 1);
+    tzset();
+    std::string file = gnss::gpx::header("test");
+    int64_t t0 = 1791230400;  // 2026-10-05 20:00:00 UTC
+    for (int i = 0; i < 50; i++) file += gnss::gpx::point(48.0 + i * 0.0001, 7.0, i % 2 == 0, 200, t0 + i * 5) + "\n";
+    file += gnss::gpx::footer();
+    for (size_t piece : {size_t(1), size_t(7), size_t(64), size_t(1000), file.size()}) {
+        GpxSummary s;
+        for (size_t at = 0; at < file.size(); at += piece) s.feed(file.data() + at, std::min(piece, file.size() - at));
+        TEST_ASSERT_EQUAL_UINT32(50, s.points());
+        TEST_ASSERT_EQUAL_INT64(t0, s.start());
+        TEST_ASSERT_EQUAL_INT64(t0 + 245, s.end());
+        TEST_ASSERT_FLOAT_WITHIN(1.0f, 49 * 11.12f, static_cast<float>(s.meters()));  // 0.0001 degree of latitude: 11.12 m
+    }
+    GpxSummary s;
+    s.feed(file.data(), file.size());
+    auto lines = s.lines();
+    TEST_ASSERT_EQUAL_size_t(4, lines.size());
+    TEST_ASSERT_EQUAL_STRING("50 points", lines[0].c_str());
+    TEST_ASSERT_EQUAL_STRING("Started 2026-10-05 20:00", lines[1].c_str());
+    TEST_ASSERT_EQUAL_STRING("Lasted 4 min 05 s", lines[2].c_str());
+    TEST_ASSERT_EQUAL_STRING("Distance 545 m", lines[3].c_str());
+}
+
+void test_gpx_from_elsewhere_and_not_gpx() {
+    GpxSummary s;
+    std::string other = "<gpx><trk><trkseg><trkpt lon=\"7.0\" lat=\"48.0\"/><trkpt lat=\"48.01\" lon=\"7.0\">\n<ele>1</ele>\n</trkpt></trkseg></trk></gpx>";
+    s.feed(other.data(), other.size());
+    TEST_ASSERT_EQUAL_UINT32(2, s.points());
+    TEST_ASSERT_EQUAL_INT64(0, s.start());
+    TEST_ASSERT_FLOAT_WITHIN(5.0f, 1112.0f, static_cast<float>(s.meters()));
+    TEST_ASSERT_EQUAL_size_t(2, s.lines().size());  // no times: points and distance only
+    GpxSummary none;
+    std::string junk(10000, 'x');
+    none.feed(junk.data(), junk.size());
+    TEST_ASSERT_EQUAL_UINT32(0, none.points());
+}
+
+void test_durations() {
+    TEST_ASSERT_EQUAL_STRING("12 s", formatDuration(12).c_str());
+    TEST_ASSERT_EQUAL_STRING("4 min 10 s", formatDuration(250).c_str());
+    TEST_ASSERT_EQUAL_STRING("1 h 02 min", formatDuration(3725).c_str());
+}
+
+// What the LoRa Capture Service writes reads back the same.
+void test_pcap_round_trip() {
+    std::vector<uint8_t> file;
+    lora::appendPcapHeader(file);
+    lora::RxInfo rx;
+    rx.frequencyHz = 869525000;
+    rx.bandwidthKHz = 250;
+    rx.spreadingFactor = 11;
+    rx.rssi = -97;
+    rx.snr = -6.25f;
+    rx.noiseFloor = -106;
+    rx.syncWord = 0x2B;
+    const uint8_t payload[] = {1, 2, 3, 4, 5};
+    lora::appendRecord(file, 1791230400, 250000, rx, payload, sizeof payload);
+    lora::appendRecord(file, 1791230401, 0, rx, payload, 0);
+
+    PcapHeader h = parsePcapHeader(file.data(), file.size());
+    TEST_ASSERT_TRUE(h.ok);
+    TEST_ASSERT_EQUAL_UINT32(kLinkLoraTap, h.linkType);
+    size_t at = kPcapHeaderSize;
+    PcapRecord r;
+    TEST_ASSERT_TRUE(parsePcapRecord(file.data() + at, file.size() - at, r));
+    TEST_ASSERT_EQUAL_UINT32(1791230400, r.seconds);
+    TEST_ASSERT_EQUAL_UINT32(250000, r.micros);
+    TEST_ASSERT_EQUAL_UINT32(lora::kLoraTapSize + 5, r.length);
+    lora::RxInfo back;
+    TEST_ASSERT_TRUE(parseLoraTap(file.data() + at + kPcapRecordSize, r.length, back));
+    TEST_ASSERT_EQUAL_UINT32(869525000, back.frequencyHz);
+    TEST_ASSERT_EQUAL_FLOAT(250, back.bandwidthKHz);
+    TEST_ASSERT_EQUAL_UINT8(11, back.spreadingFactor);
+    TEST_ASSERT_EQUAL_FLOAT(-97, back.rssi);
+    TEST_ASSERT_EQUAL_FLOAT(-6.25f, back.snr);
+    TEST_ASSERT_EQUAL_FLOAT(-106, back.noiseFloor);
+    TEST_ASSERT_EQUAL_HEX8(0x2B, back.syncWord);
+    at += kPcapRecordSize + r.length;
+    TEST_ASSERT_TRUE(parsePcapRecord(file.data() + at, file.size() - at, r));
+    TEST_ASSERT_EQUAL_UINT32(lora::kLoraTapSize, r.length);
+    at += kPcapRecordSize + r.length;
+    TEST_ASSERT_EQUAL_size_t(file.size(), at);
+    TEST_ASSERT_FALSE(parsePcapRecord(file.data() + at, file.size() - at, r));  // the end
+}
+
+void test_not_a_pcap() {
+    const uint8_t junk[24] = {'n', 'o', 'p', 'e'};
+    TEST_ASSERT_FALSE(parsePcapHeader(junk, sizeof junk).ok);
+    TEST_ASSERT_FALSE(parsePcapHeader(junk, 10).ok);
+    const uint8_t huge[16] = {0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 0xFF, 0x7F};
+    PcapRecord r;
+    TEST_ASSERT_FALSE(parsePcapRecord(huge, sizeof huge, r));
+    lora::RxInfo rx;
+    TEST_ASSERT_FALSE(parseLoraTap(junk, 10, rx));
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_hex_row);
+    RUN_TEST(test_gpx_summary);
+    RUN_TEST(test_gpx_from_elsewhere_and_not_gpx);
+    RUN_TEST(test_durations);
+    RUN_TEST(test_pcap_round_trip);
+    RUN_TEST(test_not_a_pcap);
+    return UNITY_END();
+}
@@ -0,0 +1,121 @@
+#include <unity.h>
+
+#include <string>
+
+#include "http_head.h"
+
+using namespace roro::release;
+
+void setUp() {}
+void tearDown() {}
+
+void test_a_head_in_pieces() {
+    std::string response =
+        "HTTP/1.1 200 OK\r\nContent-Type: application/json;charset=utf-8\r\nTransfer-Encoding: chunked\r\n"
+        "X-Other: a: b\r\n\r\n5\r\nhello\r\n0\r\n\r\n";
+    for (size_t piece : {size_t(1), size_t(9), response.size()}) {
+        HttpHeadParser p;
+        size_t used = 0;
+        for (size_t at = 0; at < response.size() && !p.complete(); at += piece)
+            used += p.feed(response.data() + at, std::min(piece, response.size() - at));
+        TEST_ASSERT_TRUE(p.complete());
+        TEST_ASSERT_FALSE(p.failed());
+        TEST_ASSERT_EQUAL_INT(200, p.head().status);
+        TEST_ASSERT_TRUE(p.head().chunked);
+        TEST_ASSERT_EQUAL_STRING("application/json;charset=utf-8", p.head().contentType.c_str());
+        TEST_ASSERT_EQUAL(std::string("HTTP/1.1 200 OK\r\nContent-Type: application/json;charset=utf-8\r\nTransfer-Encoding: chunked\r\nX-Other: a: b\r\n\r\n").size(), used);
+    }
+}
+
+void test_a_download_head() {
+    std::string head = "HTTP/1.1 200 OK\r\ncontent-length: 1885712\r\nCONTENT-DISPOSITION: inline; filename=a.ota\r\n\r\n\x01\x02";
+    HttpHeadParser p;
+    size_t used = p.feed(head.data(), head.size());
+    TEST_ASSERT_EQUAL_size_t(head.size() - 2, used);  // the body isn't touched
+    TEST_ASSERT_EQUAL_INT(200, p.head().status);
+    TEST_ASSERT_EQUAL_INT(1885712, p.head().contentLength);
+    TEST_ASSERT_FALSE(p.head().chunked);
+    std::string redirect = "HTTP/1.1 302 Found\r\nLocation: https://elsewhere.example/x\r\n\r\n";
+    HttpHeadParser r;
+    r.feed(redirect.data(), redirect.size());
+    TEST_ASSERT_EQUAL_INT(302, r.head().status);
+    TEST_ASSERT_EQUAL_STRING("https://elsewhere.example/x", r.head().location.c_str());
+}
+
+void test_a_head_that_is_not_http() {
+    HttpHeadParser p;
+    std::string junk = "\x16\x03\x01 not http at all\r\n\r\n";
+    p.feed(junk.data(), junk.size());
+    TEST_ASSERT_TRUE(p.failed());
+    HttpHeadParser big;
+    std::string endless = "HTTP/1.1 200 OK\r\n" + std::string(5000, 'x');
+    big.feed(endless.data(), endless.size());
+    TEST_ASSERT_TRUE(big.failed());
+    HttpHeadParser odd;
+    std::string status = "HTTP/1.1 999 What\r\n\r\n";
+    odd.feed(status.data(), status.size());
+    TEST_ASSERT_TRUE(odd.failed());
+}
+
+static std::string unchunk(const std::string& in, size_t piece, bool* done = nullptr, bool* failed = nullptr) {
+    ChunkedDecoder d;
+    std::string out;
+    for (size_t at = 0; at < in.size(); at += piece) {
+        size_t n = std::min(piece, in.size() - at);
+        std::string buf(n, '\0');
+        size_t w = d.decode(reinterpret_cast<const uint8_t*>(in.data() + at), n, reinterpret_cast<uint8_t*>(&buf[0]));
+        out.append(buf, 0, w);
+    }
+    if (done) *done = d.done();
+    if (failed) *failed = d.failed();
+    return out;
+}
+
+void test_chunked_bodies() {
+    std::string body = "5\r\nhello\r\n6;ext=1\r\n, worl\r\n1\r\nd\r\n0\r\nTrailer: x\r\n\r\n";
+    for (size_t piece : {size_t(1), size_t(2), size_t(5), body.size()}) {
+        bool done, failed;
+        TEST_ASSERT_EQUAL_STRING("hello, world", unchunk(body, piece, &done, &failed).c_str());
+        TEST_ASSERT_TRUE(done);
+        TEST_ASSERT_FALSE(failed);
+    }
+    bool done;
+    TEST_ASSERT_EQUAL_STRING("abc12345", unchunk("3\r\nabc\r\nA\r\n12345", 4, &done).c_str());  // cut short: what came is given
+    TEST_ASSERT_FALSE(done);
+    std::string hex = "1F\r\n" + std::string(31, 'x') + "\r\n0\r\n\r\n";
+    TEST_ASSERT_EQUAL_size_t(31, unchunk(hex, 3).size());
+    bool failed;
+    unchunk("zz\r\n", 1, nullptr, &failed);
+    TEST_ASSERT_TRUE(failed);
+    unchunk("3\r\nabcXX", 1, nullptr, &failed);  // no CRLF after the data
+    TEST_ASSERT_TRUE(failed);
+    unchunk("FFFFFFFFFFFFFFFFFFFF\r\n", 1, nullptr, &failed);
+    TEST_ASSERT_TRUE(failed);
+}
+
+void test_urls() {
+    Url u = parseUrl("https://git.twis.la/api/v1/repos/x?limit=10");
+    TEST_ASSERT_TRUE(u.ok);
+    TEST_ASSERT_TRUE(u.https);
+    TEST_ASSERT_EQUAL_STRING("git.twis.la", u.host.c_str());
+    TEST_ASSERT_EQUAL_STRING("/api/v1/repos/x?limit=10", u.path.c_str());
+    TEST_ASSERT_EQUAL_INT(443, u.port);
+    u = parseUrl("http://Example.COM:8080");
+    TEST_ASSERT_TRUE(u.ok);
+    TEST_ASSERT_EQUAL_STRING("example.com", u.host.c_str());
+    TEST_ASSERT_EQUAL_STRING("/", u.path.c_str());
+    TEST_ASSERT_EQUAL_INT(8080, u.port);
+    for (const char* bad : {"", "git.twis.la/x", "ftp://a/b", "https:///x", "https://u:p@host/x", "https://host:0/x", "https://ho st/x", "https://host/a b",
+                            "https://host:99999/x", "https://ho_st/x"})
+        TEST_ASSERT_FALSE_MESSAGE(parseUrl(bad).ok, bad);
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_a_head_in_pieces);
+    RUN_TEST(test_a_download_head);
+    RUN_TEST(test_a_head_that_is_not_http);
+    RUN_TEST(test_chunked_bodies);
+    RUN_TEST(test_urls);
+    return UNITY_END();
+}
@@ -0,0 +1,125 @@
+#include <unity.h>
+
+#include <map>
+#include <string>
+#include <vector>
+
+#include "json_scan.h"
+
+using namespace roro::release;
+
+void setUp() {}
+void tearDown() {}
+
+struct Seen {
+    std::vector<std::string> paths;
+    std::map<std::string, std::string> values;
+    std::map<std::string, bool> strings, cut;
+};
+
+static Seen scan(const std::string& json, size_t piece, size_t max = 300, bool* failed = nullptr, bool* done = nullptr) {
+    Seen seen;
+    JsonScanner s(
+        [&](const std::string& path, const std::string& value, bool isString, bool truncated) {
+            seen.paths.push_back(path);
+            seen.values[path] = value;
+            seen.strings[path] = isString;
+            seen.cut[path] = truncated;
+        },
+        max);
+    for (size_t at = 0; at < json.size(); at += piece) s.feed(json.data() + at, std::min(piece, json.size() - at));
+    if (failed) *failed = s.failed();
+    if (done) *done = s.done();
+    return seen;
+}
+
+void test_paths_and_kinds() {
+    std::string json = R"({"tag_name":"v0.10.0","draft":false,"size":1885712,"ratio":-1.5e3,"none":null,
+        "assets":[{"name":"a.ota","size":12},{"name":"b.bin","size":3,"tags":[]},{"name":"c","nested":{"deep":[true,"x"]}}],
+        "empty":{},"last":"end"})";
+    for (size_t piece : {size_t(1), size_t(3), size_t(7), json.size()}) {
+        bool failed, done;
+        Seen s = scan(json, piece, 300, &failed, &done);
+        TEST_ASSERT_FALSE(failed);
+        TEST_ASSERT_TRUE(done);
+        TEST_ASSERT_EQUAL_STRING("v0.10.0", s.values["tag_name"].c_str());
+        TEST_ASSERT_TRUE(s.strings["tag_name"]);
+        TEST_ASSERT_EQUAL_STRING("false", s.values["draft"].c_str());
+        TEST_ASSERT_FALSE(s.strings["draft"]);
+        TEST_ASSERT_EQUAL_STRING("1885712", s.values["size"].c_str());
+        TEST_ASSERT_EQUAL_STRING("-1.5e3", s.values["ratio"].c_str());
+        TEST_ASSERT_EQUAL_STRING("null", s.values["none"].c_str());
+        TEST_ASSERT_EQUAL_STRING("a.ota", s.values["assets[0].name"].c_str());
+        TEST_ASSERT_EQUAL_STRING("3", s.values["assets[1].size"].c_str());
+        TEST_ASSERT_EQUAL_STRING("true", s.values["assets[2].nested.deep[0]"].c_str());
+        TEST_ASSERT_EQUAL_STRING("x", s.values["assets[2].nested.deep[1]"].c_str());
+        TEST_ASSERT_EQUAL_STRING("end", s.values["last"].c_str());
+        TEST_ASSERT_EQUAL_size_t(0, s.values.count("assets[1].tags"));  // empty containers report nothing
+        TEST_ASSERT_EQUAL_size_t(0, s.values.count("empty"));
+    }
+}
+
+void test_top_level_array_and_scalars() {
+    Seen s = scan(R"([{"a":1},{"a":2},"x"])", 4);
+    TEST_ASSERT_EQUAL_STRING("2", s.values["[1].a"].c_str());
+    TEST_ASSERT_EQUAL_STRING("x", s.values["[2]"].c_str());
+    bool done;
+    s = scan("42", 1, 300, nullptr, &done);  // a number ends only when something follows it
+    TEST_ASSERT_FALSE(done);
+    s = scan("42 ", 1, 300, nullptr, &done);
+    TEST_ASSERT_TRUE(done);
+    TEST_ASSERT_EQUAL_STRING("42", s.values[""].c_str());
+}
+
+void test_escapes_and_unicode() {
+    std::string json = R"({"s":"line1\nline2\t\"q\" \\ \/ caf\u00e9 \u20ac \ud83d\ude00 end"})";
+    for (size_t piece : {size_t(1), size_t(5), json.size()}) {
+        Seen s = scan(json, piece);
+        TEST_ASSERT_EQUAL_STRING("line1\nline2\t\"q\" \\ / caf\xC3\xA9 \xE2\x82\xAC \xF0\x9F\x98\x80 end", s.values["s"].c_str());
+    }
+    std::string key = R"({"a\"b":1})";
+    TEST_ASSERT_EQUAL_STRING("1", scan(key, 2).values["a\"b"].c_str());
+}
+
+void test_long_values_are_cut_on_a_character() {
+    std::string json = "{\"body\":\"" + std::string(20, 'a') + "\xC3\xA9\xC3\xA9\"}";  // 24 bytes
+    Seen s = scan(json, 3, 21);                                                         // room for 21: the é would be cut
+    TEST_ASSERT_EQUAL_STRING(std::string(20, 'a').c_str(), s.values["body"].c_str());
+    TEST_ASSERT_TRUE(s.cut["body"]);
+    s = scan(json, 3, 22);
+    TEST_ASSERT_EQUAL_size_t(22, s.values["body"].size());
+    s = scan(json, 3, 100);
+    TEST_ASSERT_FALSE(s.cut["body"]);
+    // What follows a cut value is still read.
+    s = scan(R"({"a":"0123456789","b":"ok"})", 2, 4);
+    TEST_ASSERT_EQUAL_STRING("0123", s.values["a"].c_str());
+    TEST_ASSERT_EQUAL_STRING("ok", s.values["b"].c_str());
+}
+
+void test_what_it_can_not_follow() {
+    bool failed;
+    scan("{\"a\" 1}", 1, 300, &failed);
+    TEST_ASSERT_TRUE(failed);
+    scan("{\"a\":1,,}", 1, 300, &failed);
+    TEST_ASSERT_TRUE(failed);
+    scan("[1,2}", 1, 300, &failed);
+    TEST_ASSERT_TRUE(failed);
+    scan("<html>not json</html>", 1, 300, &failed);
+    TEST_ASSERT_TRUE(failed);
+    scan("{\"a\":\"\\u12G4\"}", 1, 300, &failed);
+    TEST_ASSERT_TRUE(failed);
+    bool done;
+    scan("{\"a\":[1,2", 2, 300, &failed, &done);  // cut short: not an error, not done
+    TEST_ASSERT_FALSE(failed);
+    TEST_ASSERT_FALSE(done);
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_paths_and_kinds);
+    RUN_TEST(test_top_level_array_and_scalars);
+    RUN_TEST(test_escapes_and_unicode);
+    RUN_TEST(test_long_values_are_cut_on_a_character);
+    RUN_TEST(test_what_it_can_not_follow);
+    return UNITY_END();
+}
@@ -0,0 +1,288 @@
+#include <unity.h>
+
+#include <string>
+#include <vector>
+
+#include "note_text.h"
+
+using namespace roro::notes;
+
+void setUp() {}
+void tearDown() {}
+
+static void type(NoteText& t, const std::string& s) {
+    for (char c : s) TEST_ASSERT_TRUE(t.insert(static_cast<uint8_t>(c)));
+}
+
+void test_typing_and_rows() {
+    NoteText t(10, 4);
+    TEST_ASSERT_EQUAL_size_t(1, t.rows().size());  // an empty note has one empty row
+    type(t, "Hello\nworld");
+    auto rows = t.rows();
+    TEST_ASSERT_EQUAL_size_t(2, rows.size());
+    TEST_ASSERT_EQUAL_STRING("Hello", rows[0].c_str());
+    TEST_ASSERT_EQUAL_STRING("world", rows[1].c_str());
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(5, t.cursorCol());
+    t.insert('\n');
+    TEST_ASSERT_EQUAL_size_t(3, t.rows().size());  // the empty line the cursor is on
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(0, t.cursorCol());
+    t.backspace();
+    t.backspace();
+    TEST_ASSERT_EQUAL_STRING("Hello\nworl", t.text().c_str());
+    TEST_ASSERT_EQUAL_STRING("Hello", t.firstLine().c_str());
+}
+
+void test_wrapping_at_spaces() {
+    NoteText t(10, 6);
+    type(t, "one two three four five");
+    auto rows = t.rows();
+    TEST_ASSERT_EQUAL_size_t(3, rows.size());
+    TEST_ASSERT_EQUAL_STRING("one two ", rows[0].c_str());  // a line owns the space it ends with
+    TEST_ASSERT_EQUAL_STRING("three four ", rows[1].c_str());  // ten characters and that space
+    TEST_ASSERT_EQUAL_STRING("five", rows[2].c_str());
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(4, t.cursorCol());
+    // Every byte is on exactly one row.
+    std::string all;
+    for (auto& r : rows) all += r;
+    TEST_ASSERT_EQUAL_STRING(t.text().c_str(), all.c_str());
+}
+
+void test_a_long_word_is_cut() {
+    NoteText t(5, 6);
+    type(t, "abcdefghijkl");
+    auto rows = t.rows();
+    TEST_ASSERT_EQUAL_size_t(3, rows.size());
+    TEST_ASSERT_EQUAL_STRING("abcde", rows[0].c_str());
+    TEST_ASSERT_EQUAL_STRING("fghij", rows[1].c_str());
+    TEST_ASSERT_EQUAL_STRING("kl", rows[2].c_str());
+}
+
+void test_left_right_over_accents() {
+    NoteText t(10, 4);
+    t.insert(0xE9);  // é
+    t.insert('t');
+    t.insert(0xE9);
+    TEST_ASSERT_EQUAL_STRING("\xC3\xA9t\xC3\xA9", t.text().c_str());
+    TEST_ASSERT_EQUAL_INT(3, t.cursorCol());
+    t.left();
+    TEST_ASSERT_EQUAL_size_t(3, t.cursor());
+    t.left();
+    t.left();
+    t.left();  // already at the start
+    TEST_ASSERT_EQUAL_size_t(0, t.cursor());
+    t.right();
+    TEST_ASSERT_EQUAL_size_t(2, t.cursor());
+    t.backspace();
+    TEST_ASSERT_EQUAL_STRING("t\xC3\xA9", t.text().c_str());
+    t.insert(0x20AC);  // €, three bytes
+    TEST_ASSERT_EQUAL_size_t(3, t.cursor());
+    t.backspace();
+    TEST_ASSERT_EQUAL_STRING("t\xC3\xA9", t.text().c_str());
+}
+
+void test_up_and_down_keep_their_column() {
+    NoteText t(20, 6);
+    TEST_ASSERT_TRUE(t.setText("a long first line\nab\n\nanother long line"));
+    t.lineEnd();
+    TEST_ASSERT_EQUAL_INT(17, t.cursorCol());
+    t.down();  // a short line: as far right as it goes
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(2, t.cursorCol());
+    t.down();  // an empty one
+    TEST_ASSERT_EQUAL_INT(0, t.cursorCol());
+    t.down();  // and back out to the column it came from
+    TEST_ASSERT_EQUAL_INT(3, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(17, t.cursorCol());
+    t.down();  // the last line: stays
+    TEST_ASSERT_EQUAL_INT(3, t.cursorRow());
+    t.up();
+    t.up();
+    t.up();
+    TEST_ASSERT_EQUAL_INT(0, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(17, t.cursorCol());
+    t.up();  // the first line: stays
+    TEST_ASSERT_EQUAL_INT(0, t.cursorRow());
+    t.left();  // moving sideways forgets the column
+    t.down();
+    TEST_ASSERT_EQUAL_INT(2, t.cursorCol());
+    t.down();
+    t.down();
+    TEST_ASSERT_EQUAL_INT(16, t.cursorCol());
+}
+
+void test_up_and_down_through_wrapped_lines() {
+    NoteText t(10, 6);
+    TEST_ASSERT_TRUE(t.setText("one two three four five\nend"));
+    // "one two " / "three four " / "five" / "end"
+    t.toEnd();
+    TEST_ASSERT_EQUAL_INT(3, t.cursorRow());
+    t.up();
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(3, t.cursorCol());
+    t.up();
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    t.lineEnd();  // on the space the line ends with, not past it
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(10, t.cursorCol());
+    t.right();  // one more is the start of the next line
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    TEST_ASSERT_EQUAL_INT(0, t.cursorCol());
+    t.lineStart();
+    t.left();
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    t.lineStart();
+    TEST_ASSERT_EQUAL_INT(0, t.cursorCol());
+    TEST_ASSERT_EQUAL_size_t(8, t.cursor());
+}
+
+void test_a_final_newline_gives_a_last_empty_line() {
+    NoteText t(10, 6);
+    TEST_ASSERT_TRUE(t.setText("ab\n"));
+    TEST_ASSERT_EQUAL_size_t(2, t.rows().size());
+    t.down();
+    TEST_ASSERT_EQUAL_size_t(3, t.cursor());
+    TEST_ASSERT_EQUAL_INT(1, t.cursorRow());
+    t.down();
+    TEST_ASSERT_EQUAL_size_t(3, t.cursor());
+    t.up();
+    TEST_ASSERT_EQUAL_size_t(0, t.cursor());
+    t.lineEnd();
+    TEST_ASSERT_EQUAL_size_t(2, t.cursor());
+}
+
+void test_the_screen_follows_the_cursor() {
+    NoteText t(10, 3);
+    std::string text;
+    for (int i = 0; i < 20; i++) text += "line " + std::to_string(i) + "\n";
+    TEST_ASSERT_TRUE(t.setText(text));
+    TEST_ASSERT_EQUAL_STRING("line 0", t.rows()[0].c_str());
+    for (int i = 0; i < 5; i++) t.down();
+    auto rows = t.rows();
+    TEST_ASSERT_EQUAL_STRING("line 3", rows[0].c_str());  // scrolled a line at a time
+    TEST_ASSERT_EQUAL_STRING("line 5", rows[2].c_str());
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    t.up();
+    t.up();
+    t.up();
+    TEST_ASSERT_EQUAL_STRING("line 2", t.rows()[0].c_str());
+    TEST_ASSERT_EQUAL_INT(0, t.cursorRow());
+    t.toEnd();
+    rows = t.rows();
+    TEST_ASSERT_EQUAL_size_t(3, rows.size());
+    TEST_ASSERT_EQUAL_STRING("line 18", rows[0].c_str());
+    TEST_ASSERT_EQUAL_STRING("", rows[2].c_str());
+    TEST_ASSERT_EQUAL_INT(2, t.cursorRow());
+    t.toStart();
+    TEST_ASSERT_EQUAL_STRING("line 0", t.rows()[0].c_str());
+    t.pageDown();
+    TEST_ASSERT_EQUAL_size_t(14, t.cursor());  // two lines down
+    t.pageUp();
+    TEST_ASSERT_EQUAL_size_t(0, t.cursor());
+    TEST_ASSERT_TRUE(t.percent() == 0);
+}
+
+// Deleting above the screen must not leave the screen starting in the middle of a line.
+void test_edits_keep_the_screen_on_line_starts() {
+    NoteText t(10, 3);
+    TEST_ASSERT_TRUE(t.setText("aaaa bbbb cccc dddd eeee ffff gggg hhhh iiii jjjj"));
+    t.toEnd();
+    t.rows();
+    for (int i = 0; i < 30; i++) {
+        t.backspace();
+        auto rows = t.rows();
+        TEST_ASSERT_TRUE(rows.size() <= 3);
+        int row = t.cursorRow();
+        TEST_ASSERT_TRUE(row >= 0 && row < static_cast<int>(rows.size()));
+        std::string all;
+        for (auto& r : rows) all += r;
+        TEST_ASSERT_TRUE(t.text().size() >= all.size());
+        TEST_ASSERT_EQUAL_STRING(t.text().substr(t.text().size() - all.size()).c_str(), all.c_str());
+    }
+}
+
+void test_full_and_too_big() {
+    NoteText t(38, 8);
+    TEST_ASSERT_FALSE(t.setText(std::string(NoteText::kMaxBytes + 1, 'x')));
+    TEST_ASSERT_TRUE(t.setText(std::string(NoteText::kMaxBytes - 1, 'x')));
+    uint32_t before = t.revision();
+    t.toEnd();
+    TEST_ASSERT_FALSE(t.insert(0xE9));  // two bytes: one too many
+    TEST_ASSERT_FALSE(t.insertText("  "));
+    TEST_ASSERT_EQUAL_UINT32(before, t.revision());
+    TEST_ASSERT_TRUE(t.insert('y'));
+    TEST_ASSERT_FALSE(t.insert('z'));
+    TEST_ASSERT_TRUE(t.revision() != before);
+    // One paragraph of 16 KB: moving through it still works.
+    t.up();
+    t.up();
+    t.lineStart();
+    TEST_ASSERT_EQUAL_size_t((NoteText::kMaxBytes / 38 - 2) * 38, t.cursor());  // two rows of 38 above the last
+}
+
+void test_crlf_becomes_lf() {
+    NoteText t(38, 8);
+    TEST_ASSERT_TRUE(t.setText("a\r\nb\r\n\rc"));
+    TEST_ASSERT_EQUAL_STRING("a\nb\n\rc", t.text().c_str());
+}
+
+// The device hands over the string it read the file into: no second copy, and never a bigger
+// buffer afterwards, whatever is typed.
+void test_adopting_a_buffer_never_reallocates() {
+    std::string body;
+    body.reserve(NoteText::kMaxBytes);
+    body = "one\r\ntwo\r\n";
+    const char* buffer = body.data();
+    NoteText t(38, 8, std::move(body));
+    TEST_ASSERT_EQUAL_STRING("one\ntwo\n", t.text().c_str());
+    TEST_ASSERT_EQUAL_PTR(buffer, t.text().data());
+    t.toEnd();
+    while (t.insert('x')) {}
+    TEST_ASSERT_EQUAL_size_t(NoteText::kMaxBytes, t.text().size());
+    TEST_ASSERT_EQUAL_PTR(buffer, t.text().data());
+    TEST_ASSERT_TRUE(t.setText("replaced"));
+    TEST_ASSERT_EQUAL_PTR(buffer, t.text().data());
+    NoteText fresh(38, 8);
+    const char* own = fresh.text().data();
+    while (fresh.insert('y')) {}
+    TEST_ASSERT_EQUAL_PTR(own, fresh.text().data());
+}
+
+void test_names() {
+    TEST_ASSERT_EQUAL_STRING("shopping-list", nameFromFirstLine("Shopping list!", "x").c_str());
+    TEST_ASSERT_EQUAL_STRING("ete-a-la-plage-2026", nameFromFirstLine("  \xC3\x89t\xC3\xA9 \xC3\xA0 la plage (2026)", "x").c_str());
+    TEST_ASSERT_EQUAL_STRING("note-20261006-0919", nameFromFirstLine("", "20261006-0919").c_str());
+    TEST_ASSERT_EQUAL_STRING("note-20261006-0919", nameFromFirstLine("\xE2\x82\xAC ?!", "20261006-0919").c_str());
+    TEST_ASSERT_TRUE(nameFromFirstLine(std::string(100, 'a'), "x").size() <= 33);
+    TEST_ASSERT_EQUAL_STRING("strase", nameFromFirstLine("Stra\xC3\x9F" "e", "x").c_str());
+}
+
+void test_titles() {
+    TEST_ASSERT_EQUAL_STRING("Shopping list", titleFrom("\n  \r\n  Shopping list  \r\nmilk\n", 24).c_str());
+    TEST_ASSERT_EQUAL_STRING("abcde", titleFrom("abcdefgh", 5).c_str());
+    TEST_ASSERT_EQUAL_STRING("\xC3\xA9t", titleFrom("\xC3\xA9t\xC3", 24).c_str());  // a character cut by the end of what was read
+    TEST_ASSERT_EQUAL_STRING("\xC3\xA9", titleFrom("\xC3\xA9t\xC3\xA9", 1).c_str());
+    TEST_ASSERT_EQUAL_STRING("", titleFrom(" \n\n", 24).c_str());
+    TEST_ASSERT_EQUAL_STRING("", titleFrom("", 24).c_str());
+}
+
+int main() {
+    UNITY_BEGIN();
+    RUN_TEST(test_typing_and_rows);
+    RUN_TEST(test_wrapping_at_spaces);
+    RUN_TEST(test_a_long_word_is_cut);
+    RUN_TEST(test_left_right_over_accents);
+    RUN_TEST(test_up_and_down_keep_their_column);
+    RUN_TEST(test_up_and_down_through_wrapped_lines);
+    RUN_TEST(test_a_final_newline_gives_a_last_empty_line);
+    RUN_TEST(test_the_screen_follows_the_cursor);
+    RUN_TEST(test_edits_keep_the_screen_on_line_starts);
+    RUN_TEST(test_full_and_too_big);
+    RUN_TEST(test_crlf_becomes_lf);
+    RUN_TEST(test_adopting_a_buffer_never_reallocates);
+    RUN_TEST(test_names);
+    RUN_TEST(test_titles);
+    return UNITY_END();
+}
@@ -31,6 +31,15 @@ void test_key_on_off_screen_only_wakes() {
    TEST_ASSERT_EQUAL(static_cast<int>(ScreenState::On), static_cast<int>(p.update(70001)));
 }

+// A key stamped a few milliseconds after the time the same pass updates with must not read as
+// 49 days of idleness: the screen stays on, and the next key acts.
+void test_activity_stamped_after_the_pass_time_keeps_the_screen_on() {
+    PowerPolicy p(30000, 60000);
+    TEST_ASSERT_FALSE(p.activity(10003));
+    TEST_ASSERT_TRUE(p.update(10000) == ScreenState::On);
+    TEST_ASSERT_FALSE(p.activity(10050));
+}
+
 void test_new_timeouts_apply_immediately() {
    PowerPolicy p(30000, 60000);
    p.activity(0);
@@ -91,6 +100,7 @@ int main() {
    RUN_TEST(test_screen_dims_then_turns_off_after_inactivity);
    RUN_TEST(test_key_on_dimmed_screen_wakes_and_still_acts);
    RUN_TEST(test_key_on_off_screen_only_wakes);
+    RUN_TEST(test_activity_stamped_after_the_pass_time_keeps_the_screen_on);
    RUN_TEST(test_new_timeouts_apply_immediately);
    RUN_TEST(test_notification_lights_an_off_screen_dimmed_until_it_ends);
    RUN_TEST(test_notification_does_not_count_as_activity);
--- a/Show More
+++ b/Show More