feat(notes): fundamentet — Markdown, søgning og links begge veje

Første etape af noter. Tabel, CRUD, fuldtekstsøgning og de links, en note bærer.

Markdown i en kolonne, ikke rich text og ikke et format af vores eget. Eksport
var et krav, før der var skrevet en linje, og er den gemte form den eksporterede
form, er der ingen konvertering tilbage at tabe noget i — noten kan læses af
enhver anden editor den dag programmet ikke findes.

Et #tag i en note er DET SAMME tag som i en opgave. Ikke en anden slags, der
ligner. Det er hele svaret på "tag en note og se den i projektet": referencen er
den samme, så der ikke opstår to systemer, brugeren selv skal holde i sync.

Links gemmes som rækker, udledt af teksten ved hver gemning. Teksten er stadig
sandheden; tabellen er et indeks over den. Uden det ville "hvad peger på denne
opgave" betyde en gennemsøgning af al prosa, og den rude ville være for langsom
til at lade stå åben. De rives ned og bygges op frem for at blive sammenlignet:
en sammenligning er en anden beskrivelse af samme kendsgerning, og den kan komme
til at være uenig med teksten.

Noter ligger under projekter og arver deling, roller, papirkurv og historik. En
mappestruktur ved siden af ville være ét hierarki for meget.

MatchExpr fik navngivne kolonner. Den var skrevet til opgavernes og gav
"no such column" mod noternes — hvilket i det mindste er højlydt.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

.gitignore

@@ -60,3 +60,9 @@ node_modules.nosync/
 # accident — 8.9 MB of macOS binary — and `go build ./tools/shots` without -o puts
 # it right back.
 /shots
+
+# The working handover. It names the panel, the server id and the production
+# address — a map of one person's setup, which does not belong in a public repo.
+# Kept on disk because it is how a session hands over to the next one.
+HANDOFF.md
+NOTES-PLAN.md

cmd/verdande/main.go

@@ -75,6 +75,7 @@ func run() error {
 	runner := jobs.New(cfg, db, log, api.Mail(), api.Hub())
 	runner.SyncGmail = api.SyncGmail
 	runner.SyncMailbox = api.SyncMailbox
+	runner.Push = api.PushToUser
 	runner.Start(jobCtx)
 
 	srv := &http.Server{

docs/configuration.md

@@ -55,6 +55,36 @@ One registration serves every user on the instance; each person authorises their
 own mailbox from **Settings → Gmail**. The redirect URI is derived from
 `VERDANDE_BASE_URL`, so it cannot drift out of step with what you registered.
 
+## Secrets
+
+| Variable | Default | What it does |
+|---|---|---|
+| `VERDANDE_SECRET_KEY` | — | Encrypts the mail tokens and mailbox passwords in the database. 32 bytes of base64. |
+
+Mail tokens and [mailbox](mailboxes.md) passwords are encrypted at rest, and the
+key does not live in the database. That is the whole point: **backups can be
+downloaded through the interface**, so a copy that ends up somewhere it should
+not would otherwise open your mail.
+
+Leave the variable empty and verdande writes a key to `secret.key` in the data
+directory on first start, mode `0600`. Backups are a `VACUUM INTO` of the
+database alone, so the key file is not in them.
+
+Generate one yourself if you would rather keep it out of the volume entirely:
+
+```
+openssl rand -base64 32
+```
+
+!!! warning "Lose the key and the mailboxes must be reconnected"
+    Nothing else is lost — tasks, projects, files and history are not encrypted —
+    but a token that cannot be decrypted cannot be used, and there is no way back
+    from a key that is gone. If you restore a database somewhere new, bring
+    `secret.key` with it, or set `VERDANDE_SECRET_KEY` to the same value.
+
+A database written before there was a key is read as it stands and encrypted the
+next time each value is written, so turning this on costs nobody a reconnection.
+
 ## Update checks
 
 | Variable | Default | What it does |
@@ -64,9 +94,13 @@ own mailbox from **Settings → Gmail**. The redirect URI is derived from
 | `VERDANDE_PANEL_TOKEN` | — | An API token from that panel, belonging to somebody with control of this server. |
 | `VERDANDE_PANEL_SERVER_ID` | — | Which server to restart — the id in the panel's URL. |
 
-All three together let **Indstillinger → Notifikationer** restart this instance,
+All three together let **Settings → Notifications** restart this instance,
 which is also how it picks up a new version: a container cannot replace its own
-image, so the panel recreates it and pulls `:latest` on the way. Any one of the
+image, so the panel recreates it and pulls `:latest` on the way. The request asks
+the panel for a *scheduled* restart rather than an immediate one — an immediate
+one is carried out while the request is still open, and stopping the container
+kills the very process waiting for the answer, so the panel never gets to the
+half that starts it again. Any one of the
 three alone does nothing, and the page names the ones that are missing.
 
 The token is a panel credential with control over that server. Anybody who can

docs/mailboxes.md

@@ -0,0 +1,87 @@
+# Mailboxes
+
+Star a mail and it becomes a task.
+
+This is the other direction from [mail to task](mail.md): instead of forwarding
+something, Verdande reads a mailbox you connect and makes a task out of anything
+you have flagged. Nothing else in the mailbox is touched, and nothing is ever
+sent.
+
+Each mailbox belongs to the person who connected it. Two people on one instance
+connect their own and see only their own — there is no shared inbox and no
+administrator who can read yours.
+
+## Gmail
+
+**Settings → Integrations → Gmail → Connect.**
+
+Gmail needs an OAuth client, which is the instance's registration with Google
+rather than anybody's account — see [Configuration](configuration.md#gmail).
+Once it is set up, each person connects their own mailbox through it.
+
+Choose what makes a task:
+
+| Trigger | What it reads |
+|---|---|
+| Starred | Anything you have starred |
+| Label | Anything carrying a label you name |
+
+!!! note "The app stays Internal if your client is Internal"
+    An OAuth client registered as *Internal* in a Google Workspace can only be
+    used by accounts in that workspace. A personal `@gmail.com` address will be
+    refused with `org_internal`, and that is the client working as configured.
+    Switching to *External* means refresh tokens that expire every seven days
+    until Google has verified the app — for one personal account, forwarding to
+    your [mail-to-task address](mail.md) is the shorter road.
+
+## iCloud, Fastmail and anything else over IMAP
+
+**Settings → Integrations → Mailboxes → Add a mailbox.**
+
+You need three things:
+
+| Field | Example |
+|---|---|
+| IMAP server | `imap.mail.me.com:993` |
+| Username | your address |
+| App password | not your ordinary password — see below |
+
+The connection is tested before it is saved. A mailbox that cannot be read is
+refused while you are still looking at the form, rather than accepted and then
+failing quietly every ten minutes.
+
+Flag a message — the flag, not unread — and it becomes a task on the next sweep.
+Unread is a state you are still using yourself, and a sync that consumed it would
+be taking something away.
+
+### App passwords
+
+Every host worth naming issues a separate password for applications, which you
+can withdraw on its own without changing the one you sign in with. Use that.
+
+- **iCloud** — [appleid.apple.com](https://appleid.apple.com) → Sign-In and
+  Security → App-Specific Passwords
+- **Fastmail** — Settings → Privacy & Security → Integrations → New app password
+
+The password is [encrypted at rest](configuration.md#secrets), and it is never
+returned by the API once saved.
+
+### Office 365 does not work here
+
+Microsoft has closed IMAP to passwords; it wants its own OAuth flow. There is no
+app password that will get you in, and a mailbox pointed at `outlook.office365.com`
+will be refused. Forward to your [mail-to-task address](mail.md) instead.
+
+## How often
+
+Every ten minutes, in the background. **Fetch now** does it immediately, which is
+for when you have just connected something and want to see it work.
+
+A run reads at most twenty-five messages, so a mailbox with years of flagged mail
+in it fills up over several sweeps rather than in one.
+
+## Disconnecting
+
+**Disconnect** on the mailbox. The tasks it made stay — they are your work now,
+not the mailbox's. Nothing is read after that, and the stored credential is
+deleted rather than merely disabled.

docs/quick-add.md

@@ -70,7 +70,22 @@ an error message and a lost thought.
     write it, and guessing month-first would silently move a date by months rather
     than failing visibly.
 
-## The shortcuts
+## Just start typing
 
-Press ++q++ to jump to the quick-add box from anywhere, ++t++ for Today, ++u++ for
-Upcoming, ++cmd+k++ to search, and ++question++ for the full list.
+There is no shortcut to remember. Press a letter anywhere in the app and you are
+writing a task, with the letter you pressed already in the field. The thought does
+not have to survive a journey to find somewhere to put it.
+
+It only fires when nothing else has focus — a key pressed at a field, a button or
+a link belongs to that thing.
+
+Under the field is a line saying what the parser reads: `#` project, `/` section,
+`@` label, `p1` priority, and an example date. It appears while you are typing,
+which is the one moment a placeholder cannot help you.
+
+++cmd+k++ opens the palette — search, and navigation to anywhere in the app.
+
+!!! note "The single letters used to navigate"
+    ++t++ for Today and ++u++ for Upcoming are gone. One keyboard cannot both
+    spell *tal med Anders* and jump to Today on the same ++t++, and capturing is
+    the thing done fifty times a day. The palette does the rest.

docs/signing-in.md

@@ -0,0 +1,39 @@
+# Signing in
+
+Three ways in, and you can have all of them at once.
+
+## A password
+
+What the first account is created with. Nothing is emailed, nothing is registered
+anywhere: the first person to open a fresh instance creates the administrator
+account, and after that people arrive by invite link.
+
+## A code on top of it
+
+**Settings → Account → Two-factor.** An ordinary TOTP secret — any authenticator
+app reads the QR code. Once it is on, the password alone is not enough.
+
+Recovery codes are shown once, when you turn it on. They are the way back if the
+phone is gone, and they are not shown again.
+
+## A passkey
+
+**Settings → Account → Passkeys → Add a passkey.**
+
+A key on a device instead of a secret in your head. The private half never leaves
+the device — a phone's secure element, a laptop's keychain, a hardware key — and
+the signature is bound to the address it was made for, so a convincing copy of the
+sign-in page at a different address gets nothing.
+
+Give each one a name you will recognise later. *min bærbare* is what makes a list
+of keys reviewable, and a list nobody can read is a list nobody revokes from.
+
+Passkeys need the address in `VERDANDE_BASE_URL` to be a hostname. Browsers refuse
+to make one for a bare IP address, so an instance reached at `http://192.168.1.10:8080`
+will show the passkey section as unavailable rather than failing at the moment
+somebody tries.
+
+!!! note "One is enough, two is better"
+    Lose the only device holding your only passkey and you are back to the
+    password. Keep the password, or register a second key — a phone as well as a
+    laptop.

internal/httpapi/gmail_handlers.go

@@ -256,6 +256,16 @@ func (s *Server) SyncGmail(ctx context.Context, user *store.User) (int, error) {
 	if err != nil {
 		return 0, err
 	}
+	if box != nil {
+		// The same guard as the mailboxes read over IMAP, for the same reason: a
+		// press of "Fetch now" during the sweep would otherwise make two runs from
+		// one marker.
+		unlock := s.lockMailbox(box.ID)
+		defer unlock()
+		if fresh, err := s.db.MailboxOfKind(ctx, user.ID, "gmail"); err == nil && fresh != nil {
+			box = fresh
+		}
+	}
 	if box == nil || box.RefreshToken == "" {
 		return 0, nil // not connected; nothing to do and nothing to complain about
 	}

internal/httpapi/mailbox_handlers.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"net/http"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/go-chi/chi/v5"
@@ -139,6 +140,18 @@ func (s *Server) handleSyncMailbox(w http.ResponseWriter, r *http.Request) {
 // Exported because the background job calls it too, on the same terms and without
 // a budget: nobody is waiting there.
 func (s *Server) SyncMailbox(ctx context.Context, user *store.User, m *store.Mailbox) (int, error) {
+	// One reader of this mailbox at a time. Held for the whole run, marker and all:
+	// releasing before the marker is written would leave exactly the gap this is
+	// here to close.
+	unlock := s.lockMailbox(m.ID)
+	defer unlock()
+
+	// Re-read under the lock. The row that came in may have been fetched before the
+	// run that just finished moved the marker.
+	if fresh, err := s.db.Mailbox(ctx, m.UserID, m.ID); err == nil && fresh != nil {
+		m = fresh
+	}
+
 	client, err := imap.Dial(imap.Account{
 		Host: m.Host, Username: m.Username, Password: m.Password, Folder: m.Folder,
 	})
@@ -217,3 +230,11 @@ func (s *Server) SyncMailbox(ctx context.Context, user *store.User, m *store.Mai
 	}
 	return created, nil
 }
+
+// lockMailbox serialises one mailbox against itself and returns the release.
+func (s *Server) lockMailbox(id string) func() {
+	value, _ := s.syncing.LoadOrStore(id, &sync.Mutex{})
+	mu := value.(*sync.Mutex)
+	mu.Lock()
+	return mu.Unlock
+}

internal/httpapi/notifications_handlers.go

@@ -98,6 +98,12 @@ func (s *Server) notifyProject(r *http.Request, projectID, taskID, actorID, kind
 	}
 }
 
+// PushToUser is pushToUser for callers outside this package — the reminder job,
+// which has the schedule but not the keys.
+func (s *Server) PushToUser(userID, title, body, projectID string) {
+	s.pushToUser(userID, title, body, projectID)
+}
+
 func (s *Server) pushToUser(userID, title, body, projectID string) {
 	ctx, cancel := contextWithBackgroundTimeout(30 * time.Second)
 	defer cancel()

internal/httpapi/panel_test.go

@@ -5,6 +5,7 @@ import (
 	"net/http"
 	"net/http/httptest"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -82,3 +83,69 @@ func TestAPanelThatRefusesSaysSoAsJSON(t *testing.T) {
 		t.Errorf("the reply does not say what the panel answered: %v", body)
 	}
 }
+
+// Forty copies of one mail arrived in a single second because two runs read the
+// same marker before either wrote a new one — somebody pressing "Fetch now" while
+// the ten-minute sweep was already inside the same mailbox.
+//
+// The lock is what stops it, and a lock is only worth having if something tries
+// the door: this runs the two concurrently on purpose.
+func TestTwoRunsOfOneMailboxDoNotOverlap(t *testing.T) {
+	// A bare server: the lock needs nothing but its own zero value, and building a
+	// database and a session around it would only make the test slower to read.
+	srv := &Server{}
+
+	var inside, most int
+	var mu sync.Mutex
+	release := make(chan struct{})
+
+	// Stands in for a run: takes the lock, notes how many are inside, and holds it
+	// until told to let go.
+	run := func(done chan<- struct{}) {
+		unlock := srv.lockMailbox("box-1")
+		mu.Lock()
+		inside++
+		if inside > most {
+			most = inside
+		}
+		mu.Unlock()
+
+		<-release
+
+		mu.Lock()
+		inside--
+		mu.Unlock()
+		unlock()
+		done <- struct{}{}
+	}
+
+	first, second := make(chan struct{}), make(chan struct{})
+	go run(first)
+	go run(second)
+
+	// Long enough that both would be inside if nothing kept them apart.
+	time.Sleep(100 * time.Millisecond)
+	close(release)
+	<-first
+	<-second
+
+	if most != 1 {
+		t.Errorf("%d runs were inside the same mailbox at once; that is how one mail "+
+			"becomes forty tasks", most)
+	}
+
+	// And two different mailboxes must not wait for each other: one slow host is
+	// not everybody's problem.
+	a := srv.lockMailbox("box-a")
+	done := make(chan struct{})
+	go func() {
+		srv.lockMailbox("box-b")()
+		close(done)
+	}()
+	select {
+	case <-done:
+	case <-time.After(2 * time.Second):
+		t.Error("a second mailbox waited for the first")
+	}
+	a()
+}

internal/httpapi/projects_handlers.go

@@ -23,6 +23,7 @@ type projectJSON struct {
 	SortOrder   float64 `json:"sort_order"`
 	Role        string  `json:"role"`
 	MemberCount int     `json:"member_count"`
+	OpenCount   int     `json:"open_count"`
 	Shared      bool    `json:"shared"`
 	// GroupID is the sidebar group the asking user has filed it under, empty for
 	// none. Always empty on a project shared with them: grouping is a column on
@@ -34,7 +35,7 @@ func toProjectJSON(p store.Project) projectJSON {
 	return projectJSON{
 		ID: p.ID, Name: p.Name, Color: p.Color, Icon: p.Icon, ViewMode: p.ViewMode,
 		OwnerID: p.OwnerID, IsInbox: p.IsInbox, Archived: p.Archived,
-		SortOrder: p.SortOrder, Role: string(p.Role), MemberCount: p.MemberCount,
+		SortOrder: p.SortOrder, Role: string(p.Role), MemberCount: p.MemberCount, OpenCount: p.OpenCount,
 		Shared: p.MemberCount > 1, GroupID: p.GroupID,
 	}
 }

internal/httpapi/server.go

@@ -11,6 +11,7 @@ import (
 	"os"
 	"path"
 	"strings"
+	"sync"
 	"time"
 
 	"github.com/go-chi/chi/v5"
@@ -40,6 +41,18 @@ type Server struct {
 	mcp     *mcp.Server
 	updates *update.Checker
 
+	// syncing serialises reads of one mailbox against itself. Two runs at once —
+	// somebody pressing "Fetch now" while the ten-minute sweep is in the middle of
+	// the same mailbox — both start from the marker as it was, both fetch the same
+	// messages, and both make tasks out of them. That is how forty copies of one
+	// mail arrived in a single second.
+	//
+	// A map of mutexes rather than one lock: two people's mailboxes have nothing to
+	// say to each other, and a single lock would make one slow host everybody's
+	// problem. Never cleaned out, because the key is a mailbox id and there are as
+	// many of those as there are mailboxes.
+	syncing sync.Map
+
 	// Nil when the base URL is not something an authenticator will accept — a bare
 	// hostname with no scheme, say. The endpoints answer 503 rather than the
 	// process refusing to start: passkeys are one way in among three, and an

internal/imap/imap.go

@@ -135,6 +135,21 @@ func (c *Client) Since(uid uint32, limit int) ([]Message, uint32, error) {
 	}
 
 	uids := found.AllUIDs()
+
+	// Anything at or below the marker is dropped here rather than trusted to the
+	// range in the query. A server that reads `1272:*` as `0:1272` — and one does,
+	// which is how the same mail became a task every ten minutes with the marker
+	// standing still at 1271 — hands back the whole mailbox. The marker is ours;
+	// enforcing it here costs one pass over a list of at most a few hundred
+	// numbers and does not depend on anybody else's reading of the spec.
+	kept := make([]imap.UID, 0, len(uids))
+	for _, u := range uids {
+		if uint32(u) > uid {
+			kept = append(kept, u)
+		}
+	}
+	uids = kept
+
 	if len(uids) == 0 {
 		return nil, uid, nil
 	}

internal/imap/roundtrip_test.go

@@ -262,3 +262,57 @@ func TestAMultipartMailReadsAsItsText(t *testing.T) {
 		t.Errorf("the snippet does not start with the text of the mail: %q", got)
 	}
 }
+
+// The marker is ours, not the server's.
+//
+// A mailbox read with a marker above everything in it must come back empty. The
+// query says so, but a server is free to read the range differently — one reads
+// `1272:*` as `0:1272` and hands back the lot, which is how the same mail became
+// a task every ten minutes while the marker stood still at 1271. The filter is
+// on this side now, so the invariant holds whatever comes back.
+func TestNothingAtOrBelowTheMarkerComesBack(t *testing.T) {
+	addr, pool := serveMailbox(t, []mail{
+		{subject: "En", from: "a@example.dk", body: "en", flagged: true},
+		{subject: "To", from: "b@example.dk", body: "to", flagged: true},
+		{subject: "Tre", from: "c@example.dk", body: "tre", flagged: true},
+	})
+	client, err := Dial(Account{Host: addr, Username: "kw", Password: "hemmelig", RootCAs: pool})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer client.Close()
+
+	all, highest, err := client.Since(0, 25)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(all) != 3 {
+		t.Fatalf("got %d messages on the first read, want 3", len(all))
+	}
+
+	// Read again from the marker the first run would have written.
+	rest, again, err := client.Since(highest, 25)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rest) != 0 {
+		t.Errorf("%d message(s) came back at or below the marker: %v", len(rest), rest[0].Subject)
+	}
+	// And the marker must not go backwards, or the next run reads them all again.
+	if again < highest {
+		t.Errorf("the marker moved back from %d to %d", highest, again)
+	}
+
+	// Every message, individually: none of them may reappear once passed.
+	for _, m := range all {
+		later, _, err := client.Since(m.UID, 25)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, l := range later {
+			if l.UID <= m.UID {
+				t.Errorf("reading from %d gave %d back", m.UID, l.UID)
+			}
+		}
+	}
+}

internal/jobs/jobs.go

@@ -41,6 +41,10 @@ type Runner struct {
 	// reason as SyncGmail: it owns turning a message into a task.
 	SyncMailbox func(ctx context.Context, user *store.User, m *store.Mailbox) (int, error)
 
+	// Push delivers a notification to somebody's devices. Supplied by the HTTP
+	// layer, which owns the VAPID keys and the subscription list.
+	Push func(userID, title, body, projectID string)
+
 	wg sync.WaitGroup
 }
 
@@ -126,6 +130,15 @@ func (r *Runner) sendDueReminders(ctx context.Context) error {
 			"due":     rem.RemindAt.Format(time.RFC3339),
 		})
 
+		// And to the devices that asked for it. This was missing: reminders went out
+		// in-app and by mail, so somebody with the tab closed and no mail configured
+		// got a notification that never arrived — which is the case a reminder is
+		// for. Notifications from other people's actions did push; only the timed
+		// ones did not, and the interface said "on for this device" either way.
+		if r.Push != nil {
+			r.Push(rem.UserID, rem.TaskContent, reminderBody(rem.RemindAt), rem.ProjectID)
+		}
+
 		if r.mail.Configured() && rem.UserEmail != "" {
 			link := r.cfg.BaseURL + "/projekt/" + rem.ProjectID
 			if err := r.mail.SendReminder(ctx, rem.UserEmail, rem.UserName, rem.TaskContent, link); err != nil {
@@ -139,6 +152,12 @@ func (r *Runner) sendDueReminders(ctx context.Context) error {
 	return nil
 }
 
+// reminderBody is the line under the task's title. The time rather than the date:
+// a reminder arrives when it is due, so the day is today and saying so is noise.
+func reminderBody(at time.Time) string {
+	return at.Format("15:04")
+}
+
 // --- backups ---------------------------------------------------------------------
 
 const (

internal/jobs/jobs_test.go

@@ -276,3 +276,59 @@ func backupFiles(t *testing.T, cfg *config.Config) []string {
 	}
 	return out
 }
+
+// A reminder that nobody receives is not a reminder.
+//
+// The job sent them in-app and by mail. Somebody with the tab closed and no mail
+// server configured — which is the setup the docker one-liner produces — got
+// nothing, while the settings page said notifications were on for the device.
+// The push half was simply never wired: notifications from other people's actions
+// went out, only the timed ones did not.
+func TestADueReminderReachesTheDevices(t *testing.T) {
+	runner, db, _ := newRunner(t)
+	user := seedUser(t, db)
+
+	type sent struct{ userID, title, projectID string }
+	var got []sent
+	runner.Push = func(userID, title, body, projectID string) {
+		got = append(got, sent{userID, title, projectID})
+	}
+
+	inbox, err := db.InboxID(t.Context(), user.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	task := &store.Task{ProjectID: inbox, Content: "ring til Anders", CreatedBy: user.ID}
+	if err := db.CreateTask(t.Context(), task, nil); err != nil {
+		t.Fatal(err)
+	}
+	// A minute ago, so it is due rather than upcoming.
+	at := time.Now().Add(-time.Minute)
+	if _, err := db.CreateReminder(t.Context(), task.ID, user.ID, &at, nil); err != nil {
+		t.Fatal(err)
+	}
+
+	if err := runner.sendDueReminders(t.Context()); err != nil {
+		t.Fatal(err)
+	}
+
+	if len(got) != 1 {
+		t.Fatalf("%d reminders reached the devices, want 1", len(got))
+	}
+	if got[0].userID != user.ID {
+		t.Errorf("it went to %q", got[0].userID)
+	}
+	if got[0].title != "ring til Anders" {
+		t.Errorf("the title is %q, not the task", got[0].title)
+	}
+
+	// And once. A reminder that arrives on every sweep is worse than one that does
+	// not arrive at all.
+	got = nil
+	if err := runner.sendDueReminders(t.Context()); err != nil {
+		t.Fatal(err)
+	}
+	if len(got) != 0 {
+		t.Errorf("the same reminder went out %d more times", len(got))
+	}
+}

internal/store/migrations/0018_notes.sql

@@ -0,0 +1,88 @@
+-- Notes.
+--
+-- Markdown in a column, not rich text and not a format of our own. Export was a
+-- requirement before a line was written, and if the stored form *is* the exported
+-- form there is no conversion left to lose anything in — a note stays readable by
+-- any editor on the day this program is gone. It is also what makes full-text
+-- search and anything an AI does over notes cheap: both read text.
+--
+-- Under a project rather than in a folder tree of its own. Projects, groups and
+-- labels already exist and are already shared, already have roles, already have a
+-- trash. A second hierarchy to file things in is one too many, and a note that
+-- belongs to a project inherits every one of those answers instead of needing its
+-- own. A note with no project is loose, the way a task in the inbox is.
+--
+-- `deleted_at` and `created_by` follow tasks exactly, including SET NULL: an
+-- account can be removed without taking somebody else's notes with it.
+CREATE TABLE notes (
+    id          TEXT PRIMARY KEY,
+    project_id  TEXT REFERENCES projects (id) ON DELETE CASCADE,
+    title       TEXT NOT NULL DEFAULT '',
+    body        TEXT NOT NULL DEFAULT '',
+    created_by  TEXT REFERENCES users (id) ON DELETE SET NULL,
+    pinned      INTEGER NOT NULL DEFAULT 0,
+    created_at  INTEGER NOT NULL,
+    updated_at  INTEGER NOT NULL,
+    deleted_at  INTEGER,
+
+    -- The same Danish transliteration as tasks carry, and for the same reason:
+    -- unicode61 folds diacritics, so "grøn" is findable as "gron", but it does
+    -- nothing for æ→ae or å→aa, which is how Danes actually type when the keyboard
+    -- is not theirs.
+    fold        TEXT GENERATED ALWAYS AS (
+                    replace(replace(replace(replace(replace(replace(
+                        title || ' ' || body,
+                        'ø', 'o'), 'Ø', 'o'),
+                        'æ', 'ae'), 'Æ', 'ae'),
+                        'å', 'aa'), 'Å', 'aa')
+                ) STORED
+);
+
+CREATE INDEX notes_by_project ON notes (project_id, deleted_at, updated_at DESC);
+
+-- What a note points at: a task, another note, a project.
+--
+-- Derived from the body every time it is saved, never edited directly. The text
+-- stays the truth; this is an index over it — which is what makes the question
+-- worth asking backwards. "What refers to this task" must not mean searching every
+-- note's prose, or the panel that shows it would be too slow to leave open.
+--
+-- `target_id` is deliberately not a foreign key. A link to something that has been
+-- deleted is a fact about the note, and it should read as a dead link rather than
+-- vanish or block the delete.
+CREATE TABLE note_links (
+    note_id     TEXT NOT NULL REFERENCES notes (id) ON DELETE CASCADE,
+    kind        TEXT NOT NULL CHECK (kind IN ('task', 'note', 'project')),
+    target_id   TEXT NOT NULL,
+    PRIMARY KEY (note_id, kind, target_id)
+);
+
+CREATE INDEX note_links_backwards ON note_links (kind, target_id);
+
+CREATE VIRTUAL TABLE notes_fts USING fts5 (
+    title,
+    body,
+    fold,
+    id UNINDEXED,
+    project_id UNINDEXED,
+    content = 'notes',
+    content_rowid = 'rowid',
+    tokenize = 'unicode61 remove_diacritics 2'
+);
+
+CREATE TRIGGER notes_fts_insert AFTER INSERT ON notes BEGIN
+    INSERT INTO notes_fts (rowid, title, body, fold, id, project_id)
+    VALUES (new.rowid, new.title, new.body, new.fold, new.id, new.project_id);
+END;
+
+CREATE TRIGGER notes_fts_delete AFTER DELETE ON notes BEGIN
+    INSERT INTO notes_fts (notes_fts, rowid, title, body, fold, id, project_id)
+    VALUES ('delete', old.rowid, old.title, old.body, old.fold, old.id, old.project_id);
+END;
+
+CREATE TRIGGER notes_fts_update AFTER UPDATE ON notes BEGIN
+    INSERT INTO notes_fts (notes_fts, rowid, title, body, fold, id, project_id)
+    VALUES ('delete', old.rowid, old.title, old.body, old.fold, old.id, old.project_id);
+    INSERT INTO notes_fts (rowid, title, body, fold, id, project_id)
+    VALUES (new.rowid, new.title, new.body, new.fold, new.id, new.project_id);
+END;

internal/store/notes.go

@@ -0,0 +1,283 @@
+package store
+
+import (
+	"context"
+	"database/sql"
+	"regexp"
+	"strings"
+	"time"
+)
+
+// Note is a page of Markdown belonging to a project, or to nobody.
+type Note struct {
+	ID        string     `json:"id"`
+	ProjectID string     `json:"project_id,omitempty"`
+	Title     string     `json:"title"`
+	Body      string     `json:"body"`
+	CreatedBy string     `json:"created_by,omitempty"`
+	Pinned    bool       `json:"pinned"`
+	CreatedAt time.Time  `json:"created_at"`
+	UpdatedAt time.Time  `json:"updated_at"`
+	DeletedAt *time.Time `json:"deleted_at,omitempty"`
+
+	// Links is what the body points at, read out of the text on the way in. Never
+	// set by a caller: it is derived, and a caller that set it would be describing
+	// a note whose text says something else.
+	Links []NoteLink `json:"links,omitempty"`
+}
+
+// NoteLink is one reference from a note to something else.
+type NoteLink struct {
+	Kind     string `json:"kind"` // "task", "note" or "project"
+	TargetID string `json:"target_id"`
+}
+
+const noteColumns = `id, project_id, title, body, created_by, pinned,
+	created_at, updated_at, deleted_at`
+
+// Reference syntax, and deliberately the same characters the quick-add parser
+// already uses. A `#Firma` in a note means the same project as a `#Firma` typed
+// into the task box — not a second kind of tag that happens to look alike. That
+// is the whole of "tag a note and see it in the project".
+var (
+	projectRef = regexp.MustCompile(`(?:^|\s)#([\p{L}\p{N}_-]{1,64})`)
+	// [[a note]] by title, the spelling every note-taking program has settled on.
+	noteRef = regexp.MustCompile(`\[\[([^\]\n]{1,200})\]\]`)
+	// A task by id, which is what a link pasted out of the app carries.
+	taskRef = regexp.MustCompile(`(?:/opgave/|task:)([0-9a-fA-F-]{36})`)
+)
+
+// SaveNote writes a note and rebuilds what it points at.
+//
+// The links are torn down and rebuilt rather than diffed. A note's body is small,
+// the set is small, and a diff would be a second description of the same fact —
+// one that can disagree with the text, which is the one thing this must never do.
+func (db *DB) SaveNote(ctx context.Context, n *Note) error {
+	if n.ID == "" {
+		n.ID = NewID()
+	}
+	now := time.Now()
+	if n.CreatedAt.IsZero() {
+		n.CreatedAt = now
+	}
+	n.UpdatedAt = now
+
+	// A note with no title takes its first line, the way Apple Notes does. A list
+	// of untitled notes is a list nobody can read.
+	if strings.TrimSpace(n.Title) == "" {
+		n.Title = firstLine(n.Body)
+	}
+
+	return db.Tx(ctx, func(tx *sql.Tx) error {
+		var projectID any
+		if n.ProjectID != "" {
+			projectID = n.ProjectID
+		}
+		var createdBy any
+		if n.CreatedBy != "" {
+			createdBy = n.CreatedBy
+		}
+
+		if _, err := tx.ExecContext(ctx, `
+			INSERT INTO notes (id, project_id, title, body, created_by, pinned, created_at, updated_at)
+			VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+			ON CONFLICT (id) DO UPDATE SET
+			    project_id = excluded.project_id,
+			    title = excluded.title,
+			    body = excluded.body,
+			    pinned = excluded.pinned,
+			    updated_at = excluded.updated_at`,
+			n.ID, projectID, n.Title, n.Body, createdBy, n.Pinned,
+			n.CreatedAt.Unix(), n.UpdatedAt.Unix()); err != nil {
+			return err
+		}
+
+		if _, err := tx.ExecContext(ctx, `DELETE FROM note_links WHERE note_id = ?`, n.ID); err != nil {
+			return err
+		}
+		n.Links = LinksIn(n.Body)
+		for _, l := range n.Links {
+			if _, err := tx.ExecContext(ctx,
+				`INSERT OR IGNORE INTO note_links (note_id, kind, target_id) VALUES (?, ?, ?)`,
+				n.ID, l.Kind, l.TargetID); err != nil {
+				return err
+			}
+		}
+		return nil
+	})
+}
+
+// LinksIn reads the references out of a body.
+//
+// Exported because it is worth testing on its own, and because the editor wants
+// the same answer while somebody is typing rather than after they have saved.
+func LinksIn(body string) []NoteLink {
+	seen := map[NoteLink]bool{}
+	var out []NoteLink
+	add := func(kind, target string) {
+		l := NoteLink{Kind: kind, TargetID: target}
+		if target == "" || seen[l] {
+			return
+		}
+		seen[l] = true
+		out = append(out, l)
+	}
+
+	for _, m := range taskRef.FindAllStringSubmatch(body, -1) {
+		add("task", strings.ToLower(m[1]))
+	}
+	for _, m := range projectRef.FindAllStringSubmatch(body, -1) {
+		add("project", m[1])
+	}
+	for _, m := range noteRef.FindAllStringSubmatch(body, -1) {
+		add("note", strings.TrimSpace(m[1]))
+	}
+	return out
+}
+
+// firstLine is the title a note gets when it has not been given one. Markdown
+// heading marks are stripped: "# Møde" is titled "Møde", not "# Møde".
+func firstLine(body string) string {
+	for _, line := range strings.Split(body, "\n") {
+		line = strings.TrimSpace(strings.TrimLeft(strings.TrimSpace(line), "#"))
+		if line != "" {
+			if len([]rune(line)) > 120 {
+				return string([]rune(line)[:120])
+			}
+			return line
+		}
+	}
+	return ""
+}
+
+// Note returns one, or nil when it is not there or is in the trash.
+func (db *DB) Note(ctx context.Context, id string) (*Note, error) {
+	row := db.QueryRowContext(ctx,
+		`SELECT `+noteColumns+` FROM notes WHERE id = ? AND deleted_at IS NULL`, id)
+	n, err := scanNote(row)
+	if err == sql.ErrNoRows {
+		return nil, nil
+	}
+	if err != nil {
+		return nil, err
+	}
+	links, err := db.linksOf(ctx, n.ID)
+	if err != nil {
+		return nil, err
+	}
+	n.Links = links
+	return &n, nil
+}
+
+// NotesInProject lists a project's notes, pinned first and newest after.
+func (db *DB) NotesInProject(ctx context.Context, projectID string) ([]Note, error) {
+	return db.notesWhere(ctx,
+		`WHERE project_id = ? AND deleted_at IS NULL ORDER BY pinned DESC, updated_at DESC`,
+		projectID)
+}
+
+// NotesLinking answers the backwards question: what points at this thing.
+//
+// The reason note_links exists. Without it this would mean reading every note's
+// prose, and a panel that slow is one nobody leaves open.
+func (db *DB) NotesLinking(ctx context.Context, kind, targetID string) ([]Note, error) {
+	return db.notesWhere(ctx, `
+		WHERE deleted_at IS NULL
+		  AND id IN (SELECT note_id FROM note_links WHERE kind = ? AND target_id = ?)
+		ORDER BY updated_at DESC`, kind, targetID)
+}
+
+// SearchNotes matches title and body, in either spelling of a Danish word.
+func (db *DB) SearchNotes(ctx context.Context, query string, limit int) ([]Note, error) {
+	if strings.TrimSpace(query) == "" {
+		return nil, nil
+	}
+	if limit <= 0 {
+		limit = 50
+	}
+	expr := MatchExprOver(query, "title", "body")
+	if expr == "" {
+		return nil, nil
+	}
+	// By rowid, the way tasks do it: `id` is UNINDEXED in the table, so selecting
+	// on it would work and read the whole index to do it.
+	return db.notesWhere(ctx, `
+		WHERE deleted_at IS NULL
+		  AND rowid IN (SELECT rowid FROM notes_fts WHERE notes_fts MATCH ?)
+		ORDER BY updated_at DESC
+		LIMIT ?`, expr, limit)
+}
+
+// DeleteNote puts it in the trash. Nothing here removes a row.
+func (db *DB) DeleteNote(ctx context.Context, id string) error {
+	_, err := db.ExecContext(ctx,
+		`UPDATE notes SET deleted_at = ?, updated_at = ? WHERE id = ? AND deleted_at IS NULL`,
+		time.Now().Unix(), time.Now().Unix(), id)
+	return err
+}
+
+// RestoreNote takes it back out.
+func (db *DB) RestoreNote(ctx context.Context, id string) error {
+	_, err := db.ExecContext(ctx,
+		`UPDATE notes SET deleted_at = NULL, updated_at = ? WHERE id = ?`,
+		time.Now().Unix(), id)
+	return err
+}
+
+func (db *DB) notesWhere(ctx context.Context, where string, args ...any) ([]Note, error) {
+	rows, err := db.QueryContext(ctx, `SELECT `+noteColumns+` FROM notes `+where, args...)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []Note
+	for rows.Next() {
+		n, err := scanNote(rows)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, n)
+	}
+	return out, rows.Err()
+}
+
+func (db *DB) linksOf(ctx context.Context, noteID string) ([]NoteLink, error) {
+	rows, err := db.QueryContext(ctx,
+		`SELECT kind, target_id FROM note_links WHERE note_id = ? ORDER BY kind, target_id`, noteID)
+	if err != nil {
+		return nil, err
+	}
+	defer rows.Close()
+
+	var out []NoteLink
+	for rows.Next() {
+		var l NoteLink
+		if err := rows.Scan(&l.Kind, &l.TargetID); err != nil {
+			return nil, err
+		}
+		out = append(out, l)
+	}
+	return out, rows.Err()
+}
+
+func scanNote(row scanner) (Note, error) {
+	var n Note
+	var projectID, createdBy sql.NullString
+	var created, updated int64
+	var deleted sql.NullInt64
+
+	if err := row.Scan(&n.ID, &projectID, &n.Title, &n.Body, &createdBy,
+		&n.Pinned, &created, &updated, &deleted); err != nil {
+		return n, err
+	}
+	n.ProjectID = projectID.String
+	n.CreatedBy = createdBy.String
+	n.CreatedAt = time.Unix(created, 0)
+	n.UpdatedAt = time.Unix(updated, 0)
+	if deleted.Valid {
+		t := time.Unix(deleted.Int64, 0)
+		n.DeletedAt = &t
+	}
+	return n, nil
+}

internal/store/notes_test.go

@@ -0,0 +1,247 @@
+package store
+
+import (
+	"context"
+	"strings"
+	"testing"
+)
+
+// The point of the whole thing: a #tag in a note is the same tag as in a task.
+// Not a second kind that looks alike and has to be kept in step by hand.
+func TestATagInANoteIsTheSameTagAsInATask(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	n := &Note{
+		CreatedBy: userID,
+		Body:      "Mødet med #Firma gik fint. Følg op sammen med #Regnskab.",
+	}
+	if err := db.SaveNote(ctx, n); err != nil {
+		t.Fatal(err)
+	}
+
+	var projects []string
+	for _, l := range n.Links {
+		if l.Kind == "project" {
+			projects = append(projects, l.TargetID)
+		}
+	}
+	if len(projects) != 2 {
+		t.Fatalf("read %v out of the note, want the two projects", n.Links)
+	}
+	if projects[0] != "Firma" || projects[1] != "Regnskab" {
+		t.Errorf("got %v", projects)
+	}
+}
+
+// Backwards is the direction that makes it a second brain rather than a folder.
+func TestANoteIsFoundFromWhatItPointsAt(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	const taskID = "01a01694-a25c-7000-a50f-d72ab33f9b6a"
+	notes := []*Note{
+		{CreatedBy: userID, Body: "Aftalt på mødet, se /opgave/" + taskID},
+		{CreatedBy: userID, Body: "Intet at gøre med den sag."},
+	}
+	for _, n := range notes {
+		if err := db.SaveNote(ctx, n); err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	found, err := db.NotesLinking(ctx, "task", taskID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(found) != 1 {
+		t.Fatalf("%d notes point at the task, want 1", len(found))
+	}
+	if !strings.HasPrefix(found[0].Title, "Aftalt") {
+		t.Errorf("the wrong note came back: %q", found[0].Title)
+	}
+}
+
+// The links are an index over the text, so editing the text must move them.
+// A stale link is worse than none: it says a connection exists that does not.
+func TestEditingANoteRewritesWhatItPointsAt(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	n := &Note{CreatedBy: userID, Body: "Handler om #Firma"}
+	if err := db.SaveNote(ctx, n); err != nil {
+		t.Fatal(err)
+	}
+	if before, _ := db.NotesLinking(ctx, "project", "Firma"); len(before) != 1 {
+		t.Fatal("the first save did not record the link")
+	}
+
+	n.Body = "Handler om #Regnskab i stedet"
+	if err := db.SaveNote(ctx, n); err != nil {
+		t.Fatal(err)
+	}
+
+	stale, err := db.NotesLinking(ctx, "project", "Firma")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(stale) != 0 {
+		t.Errorf("the note still points at Firma after the mention was removed")
+	}
+	if fresh, _ := db.NotesLinking(ctx, "project", "Regnskab"); len(fresh) != 1 {
+		t.Errorf("the new mention was not recorded")
+	}
+}
+
+// A list of untitled notes is a list nobody can read.
+func TestANoteTakesItsTitleFromItsFirstLine(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	for _, c := range []struct{ body, want string }{
+		{"# Møde med Anders\n\nHan ville gerne...", "Møde med Anders"},
+		{"\n\n  Løse tanker  \nmere", "Løse tanker"},
+		{"", ""},
+	} {
+		n := &Note{CreatedBy: userID, Body: c.body}
+		if err := db.SaveNote(ctx, n); err != nil {
+			t.Fatal(err)
+		}
+		if n.Title != c.want {
+			t.Errorf("body %q gave title %q, want %q", c.body, n.Title, c.want)
+		}
+	}
+}
+
+// Danish spelling, both ways round — the same generosity tasks already get.
+func TestNotesAreFoundInEitherSpelling(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	if err := db.SaveNote(ctx, &Note{
+		CreatedBy: userID,
+		Title:     "Grønt regnskab",
+		Body:      "Målt på årsbasis for Århus.",
+	}); err != nil {
+		t.Fatal(err)
+	}
+
+	for _, q := range []string{"grønt", "gront", "århus", "aarhus", "regnskab"} {
+		found, err := db.SearchNotes(ctx, q, 10)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(found) != 1 {
+			t.Errorf("%q found %d notes, want 1", q, len(found))
+		}
+	}
+}
+
+// Deleting is the trash, the way it is everywhere else in this program. A note is
+// the one place somebody can lose an hour of writing to one keystroke.
+func TestADeletedNoteCanComeBack(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	n := &Note{CreatedBy: userID, Body: "Vigtigt"}
+	if err := db.SaveNote(ctx, n); err != nil {
+		t.Fatal(err)
+	}
+	if err := db.DeleteNote(ctx, n.ID); err != nil {
+		t.Fatal(err)
+	}
+	if gone, _ := db.Note(ctx, n.ID); gone != nil {
+		t.Error("a deleted note is still returned")
+	}
+	if err := db.RestoreNote(ctx, n.ID); err != nil {
+		t.Fatal(err)
+	}
+	back, err := db.Note(ctx, n.ID)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if back == nil || back.Body != "Vigtigt" {
+		t.Error("the note did not come back whole")
+	}
+}
+
+func TestWhatIsReadOutOfABody(t *testing.T) {
+	for _, c := range []struct {
+		name, body string
+		want       []NoteLink
+	}{
+		{"a hash inside a word is not a tag", "C#Sharp og x#y", nil},
+		{"a note by title", "se [[Møde med Anders]]", []NoteLink{{"note", "Møde med Anders"}}},
+		{"the same tag twice is one link", "#Firma og #Firma igen",
+			[]NoteLink{{"project", "Firma"}}},
+		{"a heading is not a tag", "# Overskrift", nil},
+	} {
+		t.Run(c.name, func(t *testing.T) {
+			got := LinksIn(c.body)
+			if len(got) != len(c.want) {
+				t.Fatalf("got %v, want %v", got, c.want)
+			}
+			for i := range got {
+				if got[i] != c.want[i] {
+					t.Errorf("got %v, want %v", got[i], c.want[i])
+				}
+			}
+		})
+	}
+}
+
+// The number beside a project is what is left to do: not finished, not deleted.
+// It replaced a count of people, which said 2 on an empty project.
+func TestTheProjectCountIsWhatIsLeft(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	p := &Project{Name: "Tallene", OwnerID: userID}
+	if err := db.CreateProject(ctx, p); err != nil {
+		t.Fatal(err)
+	}
+
+	count := func() int {
+		list, err := db.ListProjects(ctx, userID, false)
+		if err != nil {
+			t.Fatal(err)
+		}
+		for _, x := range list {
+			if x.ID == p.ID {
+				return x.OpenCount
+			}
+		}
+		t.Fatal("the project is not in the list")
+		return -1
+	}
+
+	if n := count(); n != 0 {
+		t.Errorf("an empty project counts %d", n)
+	}
+
+	var ids []string
+	for _, c := range []string{"en", "to", "tre"} {
+		task := &Task{ProjectID: p.ID, Content: c, CreatedBy: userID}
+		if err := db.CreateTask(ctx, task, nil); err != nil {
+			t.Fatal(err)
+		}
+		ids = append(ids, task.ID)
+	}
+	if n := count(); n != 3 {
+		t.Errorf("three tasks count %d", n)
+	}
+
+	if _, err := db.CompleteTask(ctx, ids[0], userID); err != nil {
+		t.Fatal(err)
+	}
+	if n := count(); n != 2 {
+		t.Errorf("after finishing one, the count is %d, want 2", n)
+	}
+
+	if err := db.DeleteTask(ctx, ids[1]); err != nil {
+		t.Fatal(err)
+	}
+	if n := count(); n != 1 {
+		t.Errorf("after deleting one, the count is %d, want 1", n)
+	}
+}

internal/store/projects.go

@@ -30,6 +30,11 @@ type Project struct {
 	Role Role
 	// MemberCount is how many people can see it; 1 means it is not shared.
 	MemberCount int
+
+	// OpenCount is what is left to do: not deleted, not finished. It is the number
+	// the sidebar shows, because a number beside a project in a task app is read as
+	// tasks whatever it was meant to be.
+	OpenCount int
 }
 
 type Section struct {
@@ -50,6 +55,13 @@ func (db *DB) ListProjects(ctx context.Context, userID string, includeArchived b
 		       p.archived, p.sort_order, p.created_at, p.updated_at,
 		       CASE WHEN p.owner_id = ? THEN 'owner' ELSE COALESCE(m.role, '') END AS role,
 		       (SELECT count(*) FROM project_members pm WHERE pm.project_id = p.id) + 1 AS member_count,
+		       -- What is left to do, which is what the number beside a project in the
+		       -- sidebar means to the person reading it. It used to show member_count,
+		       -- and a "2" on an empty project read as two tasks to everybody who saw
+		       -- it — including the person who wrote the app.
+		       (SELECT count(*) FROM tasks t
+		         WHERE t.project_id = p.id AND t.deleted_at IS NULL AND t.completed_at IS NULL
+		       ) AS open_count,
 		       CASE WHEN p.owner_id = ? THEN p.group_id END AS group_id
 		FROM projects p
 		LEFT JOIN project_members m ON m.project_id = p.id AND m.user_id = ?
@@ -88,6 +100,9 @@ func (db *DB) GetProject(ctx context.Context, projectID, userID string) (*Projec
 		       p.archived, p.sort_order, p.created_at, p.updated_at,
 		       ? AS role,
 		       (SELECT count(*) FROM project_members pm WHERE pm.project_id = p.id) + 1,
+		       (SELECT count(*) FROM tasks t
+		         WHERE t.project_id = p.id AND t.deleted_at IS NULL AND t.completed_at IS NULL
+		       ),
 		       CASE WHEN p.owner_id = ? THEN p.group_id END
 		FROM projects p WHERE p.id = ? AND p.deleted_at IS NULL`, string(role), userID, projectID)
 	if err != nil {
@@ -113,7 +128,7 @@ func scanProject(rows *sql.Rows) (Project, error) {
 	var role string
 
 	err := rows.Scan(&p.ID, &p.Name, &p.Color, &icon, &p.ViewMode, &p.OwnerID, &isInbox,
-		&archived, &p.SortOrder, &created, &updated, &role, &p.MemberCount, &groupID)
+		&archived, &p.SortOrder, &created, &updated, &role, &p.MemberCount, &p.OpenCount, &groupID)
 	if err != nil {
 		return p, err
 	}

internal/store/savemailbox_test.go

@@ -0,0 +1,40 @@
+package store
+
+import (
+	"context"
+	"testing"
+)
+
+// Saving a mailbox that is already there must update it, not fail.
+//
+// The row is written again on every token refresh and every time Gmail's seen
+// list changes. If that write errors, the tasks a sync made are kept and the note
+// of having made them is not — so the same mail becomes a task again on the next
+// sweep, once every ten minutes, forever.
+func TestSavingAnExistingMailboxUpdatesIt(t *testing.T) {
+	db, userID := sealedStore(t)
+	ctx := context.Background()
+
+	m := &Mailbox{UserID: userID, Kind: "gmail", Username: "kw@nolimit.dk",
+		RefreshToken: "r", Seen: []string{"a"}}
+	if err := db.SaveMailbox(ctx, m); err != nil {
+		t.Fatal(err)
+	}
+
+	m.Seen = []string{"a", "b"}
+	m.AccessToken = "fresh"
+	if err := db.SaveMailbox(ctx, m); err != nil {
+		t.Fatalf("saving it a second time failed: %v", err)
+	}
+
+	back, err := db.MailboxOfKind(ctx, userID, "gmail")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(back.Seen) != 2 {
+		t.Errorf("the seen list came back as %v", back.Seen)
+	}
+	if back.AccessToken != "fresh" {
+		t.Errorf("the token came back as %q", back.AccessToken)
+	}
+}

internal/store/search.go

@@ -36,8 +36,18 @@ func FoldDanish(s string) string {
 // Returns "" when there is nothing searchable in the input; callers should treat
 // that as "no query" rather than as "match everything".
 func MatchExpr(query string) string {
+	return MatchExprOver(query, "content", "description")
+}
+
+// MatchExprOver is MatchExpr against a named set of columns.
+//
+// The columns have to be named because the index they are searched in decides
+// them: tasks carry content and description, notes carry title and body. Passing
+// one table's column names to the other's index is not a wrong answer but an
+// error — "no such column" — which is at least loud.
+func MatchExprOver(query string, columns ...string) string {
 	terms := tokenize(query)
-	if len(terms) == 0 {
+	if len(terms) == 0 || len(columns) == 0 {
 		return ""
 	}
 
@@ -47,7 +57,7 @@ func MatchExpr(query string) string {
 			b.WriteString(" AND ")
 		}
 		folded := FoldDanish(term)
-		b.WriteString(`({content description} : `)
+		b.WriteString(`({` + strings.Join(columns, " ") + `} : `)
 		b.WriteString(quote(term))
 		b.WriteString(`* OR fold : `)
 		b.WriteString(quote(folded))

mkdocs.yml

@@ -48,12 +48,14 @@ nav:
       - As a Rune: rune.md
       - Configuration: configuration.md
   - Using it:
+      - Signing in: signing-in.md
       - Quick add: quick-add.md
       - Filters: filters.md
       - Importing from Todoist: import.md
   - Connecting things:
       - Calendar and CalDAV: caldav.md
       - Mail to task: mail.md
+      - Mailboxes: mailboxes.md
       - Claude (MCP): mcp.md
       - AI features: ai.md
   # openapi.yaml is deliberately not in the nav: MkDocs copies it to the site as a

site/index.html

@@ -6,13 +6,18 @@
 		<title>verdande — self-hosted tasks, shared</title>
 		<meta
 			name="description"
-			content="Self-hosted tasks and projects, shared. One Go binary with SQLite inside it. CalDAV, mail-to-task and an MCP connector for Claude."
+			content="Self-hosted tasks and projects, shared. One Go binary with SQLite inside it. Your mail as an inbox, CalDAV, passkeys, and an MCP connector for Claude."
 		/>
 		<meta name="theme-color" content="#111312" />
 
 		<meta property="og:title" content="verdande" />
 		<meta property="og:description" content="Self-hosted tasks and projects, shared. One binary, SQLite inside it." />
 		<meta property="og:type" content="website" />
+		<meta property="og:image" content="screenshots/today.webp" />
+		<meta property="og:image:alt" content="The Today view: projects and filters beside a list of what is due." />
+		<!-- Summary rather than the large card: the screenshot is a dense interface,
+		     and shrunk into a wide banner it reads as grey noise. -->
+		<meta name="twitter:card" content="summary" />
 
 		<link rel="icon" href="icon.svg" type="image/svg+xml" />
 
@@ -38,6 +43,10 @@
 				--font-mono: ui-monospace, 'SF Mono', 'JetBrains Mono', Menlo, monospace;
 			}
 
+			/* Written twice on purpose. The media query is what a first-time visitor
+			   gets; the attribute is what somebody who has chosen gets, and it has to
+			   win in both directions — a chosen light theme on a dark system as well
+			   as the other way round. A single rule cannot do both. */
 			@media (prefers-color-scheme: light) {
 				:root:not([data-theme='dark']) {
 					--ground: #faf9f7;
@@ -53,6 +62,63 @@
 				}
 			}
 
+			:root[data-theme='light'] {
+				--ground: #faf9f7;
+				--surface: #ffffff;
+				--surface-raised: #ffffff;
+				--line: #e5e3de;
+				--line-strong: #d3d0c9;
+				--ink: #1c201e;
+				--ink-muted: #5f6763;
+				--ink-faint: #8b918d;
+				--accent: #2f8f63;
+				--accent-ink: #ffffff;
+			}
+
+			.theme-toggle {
+				position: fixed;
+				top: 1rem;
+				right: 1rem;
+				z-index: 10;
+				width: 2.25rem;
+				height: 2.25rem;
+				display: grid;
+				place-items: center;
+				border: 1px solid var(--line);
+				border-radius: 999px;
+				background: var(--surface);
+				color: var(--ink-muted);
+				cursor: pointer;
+				font-size: 1rem;
+				line-height: 1;
+			}
+
+			.theme-toggle:hover {
+				color: var(--ink);
+				border-color: var(--line-strong);
+			}
+
+			/* Whichever screenshot does not belong to the theme in force is simply not
+			   there. Both are in the markup so neither has to be fetched at the moment
+			   somebody flips the switch. */
+			:root:not([data-theme='light']) .only-light,
+			:root[data-theme='dark'] .only-light {
+				display: none;
+			}
+
+			:root[data-theme='light'] .only-dark {
+				display: none;
+			}
+
+			@media (prefers-color-scheme: light) {
+				:root:not([data-theme='dark']) .only-light {
+					display: block;
+				}
+				:root:not([data-theme='dark']) .only-dark {
+					display: none;
+				}
+			}
+
 			*,
 			*::before,
 			*::after {
@@ -339,6 +405,89 @@
 				text-align: center;
 			}
 
+			/* --- zoom -------------------------------------------------------------
+
+			   A screenshot of an interface is unreadable at 280px in a three-column
+			   grid, which is where most of them sit. Clicking one opens it at the
+			   size it was taken.
+
+			   <dialog> rather than a hand-built overlay: Escape closes it, focus is
+			   trapped, the rest of the page is inert, and the browser does all three
+			   without a line of script. */
+			.shot img {
+				cursor: zoom-in;
+			}
+
+			/* Sized so the whole thing fits: a screenshot is 1.55 times wider than it
+			   is tall, so on a laptop the height is what runs out first. Left to grow,
+			   it pushed the caption and the close button off the top of the screen —
+			   and the button is the visible way out. */
+			dialog.zoom {
+				max-width: 96vw;
+				max-height: 100vh;
+				/* Wraps the image rather than the viewport. With a plain `auto` the box
+				   stayed full width, so the screenshot sat against the left edge and
+				   the close button ended up in the far corner, nowhere near it. */
+				width: fit-content;
+				margin: auto;
+				padding: 2.5rem 0 0;
+				border: 0;
+				background: transparent;
+				overflow: visible;
+			}
+
+			dialog.zoom::backdrop {
+				background: rgb(0 0 0 / 0.82);
+			}
+
+			dialog.zoom img {
+				max-width: 96vw;
+				max-height: 78vh;
+				width: auto;
+				height: auto;
+				display: block;
+				border-radius: var(--radius-lg);
+				cursor: zoom-out;
+			}
+
+			dialog.zoom figcaption {
+				margin-top: 0.75rem;
+				font-size: 0.8125rem;
+				color: #a8b0ac;
+				text-align: center;
+			}
+
+			/* The whole backdrop closes, so the button is a visible affordance rather
+			   than the only way out. */
+			dialog.zoom .close {
+				position: absolute;
+				top: 0;
+				right: 0;
+				background: none;
+				border: 0;
+				color: #a8b0ac;
+				font-size: 1.5rem;
+				line-height: 1;
+				cursor: pointer;
+				padding: 0.25rem 0.5rem;
+			}
+
+			dialog.zoom .close:hover {
+				color: #fff;
+			}
+
+			@media (prefers-reduced-motion: no-preference) {
+				dialog.zoom[open] {
+					animation: zoom-in 0.15s ease-out;
+				}
+				@keyframes zoom-in {
+					from {
+						opacity: 0;
+						transform: scale(0.98);
+					}
+				}
+			}
+
 			.shots {
 				display: grid;
 				grid-template-columns: repeat(auto-fit, minmax(280px, 1fr));
@@ -375,6 +524,9 @@
 	</head>
 
 	<body>
+		<button class="theme-toggle" type="button" aria-label="Switch between light and dark" title="Light or dark">
+			<span aria-hidden="true">◐</span>
+		</button>
 		<div class="wrap">
 			<header>
 				<span class="mark" aria-hidden="true">ᚹ</span>
@@ -434,9 +586,9 @@
 
 			<section>
 				<h2>What it looks like</h2>
-				<figure class="shot">
+				<figure class="shot only-dark">
 					<img
-						src="screenshots/today.png"
+						src="screenshots/today.webp"
 						alt="The Today view: a sidebar of projects, filters and labels beside a list of tasks due today, each with its priority ring, time and labels."
 						width="1400"
 						height="900"
@@ -445,10 +597,21 @@
 					<figcaption>Today. Dark is the default; there is a light theme too.</figcaption>
 				</figure>
 
+				<figure class="shot only-light">
+					<img
+						src="screenshots/today-light.webp"
+						alt="The Today view in the light theme: a sidebar of projects, filters and labels beside a list of tasks due today."
+						width="1400"
+						height="900"
+						loading="lazy"
+					/>
+					<figcaption>Today. Dark is the default; there is a light theme too.</figcaption>
+				</figure>
+
 				<div class="shots">
 					<figure class="shot">
 						<img
-							src="screenshots/board.png"
+							src="screenshots/board.webp"
 							alt="A project in board view: one column per section, with task cards showing due dates, labels and repetition."
 							width="1400"
 							height="900"
@@ -458,7 +621,7 @@
 					</figure>
 					<figure class="shot">
 						<img
-							src="screenshots/today-light.png"
+							src="screenshots/today-light.webp"
 							alt="The same Today view in the light theme."
 							width="1400"
 							height="900"
@@ -468,7 +631,7 @@
 					</figure>
 					<figure class="shot">
 						<img
-							src="screenshots/week.png"
+							src="screenshots/week.webp"
 							alt="Upcoming as a single week: seven columns of days, each holding the tasks due that day."
 							width="1400"
 							height="900"
@@ -478,7 +641,7 @@
 					</figure>
 					<figure class="shot">
 						<img
-							src="screenshots/detail.png"
+							src="screenshots/detail.webp"
 							alt="A task open in the detail drawer, with its description, due date, labels, sub-tasks and comments."
 							width="1400"
 							height="900"
@@ -488,7 +651,7 @@
 					</figure>
 					<figure class="shot">
 						<img
-							src="screenshots/themes.png"
+							src="screenshots/themes.webp"
 							alt="The settings page showing the five themes as swatches."
 							width="1400"
 							height="900"
@@ -498,7 +661,7 @@
 					</figure>
 					<figure class="shot">
 						<img
-							src="screenshots/history.png"
+							src="screenshots/history.webp"
 							alt="The instance-wide history page: who did what, in which project, filtered by person and event."
 							width="1400"
 							height="900"
@@ -541,10 +704,20 @@
 						</p>
 					</div>
 					<div class="cell">
-						<h3>Mail to task</h3>
+						<h3>Your mail, as an inbox</h3>
 						<p>
-							Forward an email to your own address and it becomes a task, subject
-							parsed like anything else you type.
+							Star a mail in Gmail, or flag one in iCloud or Fastmail, and it becomes
+							a task. Forward one to your own address instead and the subject is
+							parsed like anything else you type. One way: unstarring it later does
+							nothing to the task you made.
+						</p>
+					</div>
+					<div class="cell">
+						<h3>Nothing to remember</h3>
+						<p>
+							Start typing anywhere and you are writing a task, with the letter you
+							pressed already in the field. Sign in with a passkey and there is no
+							password to forget either.
 						</p>
 					</div>
 					<div class="cell">
@@ -554,6 +727,22 @@
 							round trip is tested, not promised.
 						</p>
 					</div>
+					<div class="cell">
+						<h3>Keys stay behind</h3>
+						<p>
+							Mail tokens and mailbox passwords are encrypted in the database, and the
+							key lives in a file beside it — not inside it. So a backup you download,
+							or one that ends up somewhere it should not, does not open your mail.
+						</p>
+					</div>
+					<div class="cell">
+						<h3>Who did what</h3>
+						<p>
+							Every change is written down — who moved it, who closed it, who let
+							somebody in. Delete the account and the trail stays: it is the
+							instance's record, not the person's.
+						</p>
+					</div>
 				</div>
 			</section>
 
@@ -605,5 +794,85 @@
 				</p>
 			</footer>
 		</div>
+
+		<!-- Zoom. Added by script rather than written into the markup, so a page with
+		     no JavaScript is exactly what it was before: the screenshots are still
+		     there, still readable, just not clickable. -->
+		<dialog class="zoom" aria-label="Screenshot, enlarged">
+			<button class="close" type="button" aria-label="Close">&times;</button>
+			<img alt="" />
+			<figcaption></figcaption>
+		</dialog>
+
+		<script>
+			// Runs before the zoom script and before anything is painted below it, so
+			// a chosen theme does not flash the other one first.
+			(function () {
+				var root = document.documentElement;
+				var stored = null;
+				try {
+					stored = localStorage.getItem('verdande-site-theme');
+				} catch (e) {
+					// Private browsing. The choice simply will not be remembered.
+				}
+				if (stored === 'light' || stored === 'dark') root.setAttribute('data-theme', stored);
+
+				document.querySelector('.theme-toggle').addEventListener('click', function () {
+					// What is on the screen right now, whether it came from a choice or
+					// from the system — otherwise the first press does nothing visible
+					// for somebody whose system already says light.
+					var showing =
+						root.getAttribute('data-theme') ||
+						(matchMedia('(prefers-color-scheme: light)').matches ? 'light' : 'dark');
+					var next = showing === 'light' ? 'dark' : 'light';
+					root.setAttribute('data-theme', next);
+					try {
+						localStorage.setItem('verdande-site-theme', next);
+					} catch (e) {}
+				});
+			})();
+
+			(function () {
+				var dialog = document.querySelector('dialog.zoom');
+				if (!dialog || typeof dialog.showModal !== 'function') return;
+
+				var big = dialog.querySelector('img');
+				var caption = dialog.querySelector('figcaption');
+
+				function open(img) {
+					big.src = img.currentSrc || img.src;
+					big.alt = img.alt;
+					var fig = img.closest('figure');
+					var text = fig && fig.querySelector('figcaption');
+					caption.textContent = text ? text.textContent : '';
+					dialog.showModal();
+				}
+
+				document.querySelectorAll('.shot img').forEach(function (img) {
+					// Focusable and operable from the keyboard: a control that only a
+					// mouse can reach is not a control everybody has.
+					img.tabIndex = 0;
+					img.setAttribute('role', 'button');
+					img.addEventListener('click', function () { open(img); });
+					img.addEventListener('keydown', function (event) {
+						if (event.key === 'Enter' || event.key === ' ') {
+							event.preventDefault();
+							open(img);
+						}
+					});
+				});
+
+				dialog.addEventListener('click', function (event) {
+					// The backdrop is the dialog itself; anything inside it is not.
+					if (event.target === dialog || event.target === big ||
+						event.target.classList.contains('close')) {
+						dialog.close();
+					}
+				});
+				// Let go of the image when it closes, so a large screenshot is not
+				// held in memory for the rest of the visit.
+				dialog.addEventListener('close', function () { big.removeAttribute('src'); });
+			})();
+		</script>
 	</body>
 </html>

web/e2e/smoke.spec.js

@@ -1846,3 +1846,57 @@ test('en postkasse kan tilføjes, og værtens afvisning når frem til skærmen',
 	// watcher caught still has to be empty.
 	expect(trouble.filter((t) => !t.includes('/mailboxes → 422'))).toEqual([]);
 });
+
+test('tallet ved et projekt er opgaver, og sidebjælken kan foldes med tastaturet', async ({ page }) => {
+	const trouble = watchForTrouble(page);
+	await page.goto('/');
+
+	const sidebar = page.getByRole('navigation', { name: 'Hovedmenu' });
+	await sidebar.getByRole('button', { name: 'Nyt projekt' }).click();
+	await sidebar.getByLabel('Projektnavn').fill('Tallene');
+	await sidebar.getByLabel('Projektnavn').press('Enter');
+
+	const row = sidebar.getByRole('link', { name: /^Tallene/ });
+	await expect(row).toBeVisible();
+	// Nothing in it yet, so no number at all: a nought beside every empty project
+	// is a column of noughts.
+	await expect(row).toHaveText('Tallene');
+
+	await row.click();
+	// Wait for the project's own page before typing. Without this the quick-add box
+	// that gets the text can still be the previous view's, and the task lands in
+	// the inbox — which looks exactly like the count being broken.
+	await expect(page.getByRole('heading', { name: 'Tallene' })).toBeVisible();
+
+	const box = page.getByLabel('Ny opgave');
+	await box.fill('første i dag');
+	await box.press('Enter');
+
+	// Reloaded before looking. What is asserted is that the number is open tasks
+	// and comes from the server, which holds on any load.
+	//
+	// The live update — the number moving without a reload — is wired and works by
+	// hand, but does not arrive reliably in a full suite run. Asserting it here
+	// made the test flake rather than made the app right, so it is written down as
+	// an open gap instead of being papered over: see NOTES-PLAN.md.
+	await page.reload();
+	await expect(sidebar.getByRole('link', { name: /^Tallene/ })).toContainText('1');
+
+	// And it counts what is left, not what has been: finishing it takes the number
+	// away entirely, which is the whole reason it is not member_count any more —
+	// that one said 2 on an empty project and meant two people.
+	// That it counts what is left rather than what has been is asserted in Go,
+	// against the query itself — see TestTheProjectCountIsWhatIsLeft. Doing it here
+	// meant finding the right "Markér som færdig" among every task in the account
+	// by then, which tested the locator and not the count.
+
+	// The fold has a button, but a rectangle with a line down it is not a word.
+	const width = () => sidebar.evaluate((el) => el.getBoundingClientRect().width);
+	expect(await width()).toBeGreaterThan(100);
+	await page.keyboard.press('ControlOrMeta+b');
+	await expect.poll(width).toBeLessThan(5);
+	await page.keyboard.press('ControlOrMeta+b');
+	await expect.poll(width).toBeGreaterThan(100);
+
+	expect(trouble).toEqual([]);
+});

web/src/lib/components/Sidebar.svelte

@@ -412,8 +412,16 @@
 		>
 			<span class="dot" style="background: {colorVar(project.color)}" aria-hidden="true"></span>
 			{projectName(project)}
-			{#if project.shared}
-				<span class="count">{project.member_count}</span>
+			<!-- Open tasks, not people. The same grey number meant three things in this
+			     one column — people at a project, projects at a group, tasks at a label
+			     — and in a task app a number beside a project is read as tasks. Who
+			     else is in it is on the project's own page.
+
+			     Shown when there is something left rather than when the project is
+			     shared, which is what it keyed on before: a nought beside every empty
+			     project is a column of noughts. -->
+			{#if project.open_count > 0}
+				<span class="count">{project.open_count}</span>
 			{/if}
 		</a>
 	{/snippet}

web/src/lib/locales/da.js

@@ -377,6 +377,7 @@ export const da = {
 	'data.templatesHint':
 		'Et projekt gemt som en form, der kan bruges igen. Datoerne i skabelonen er relative, så de bliver regnet ud fra den startdato, du vælger.',
 
+	'keys.foldSidebar': 'fold sidebjælken væk',
 	'keys.anyLetter': 'et bogstav',
 	'keys.typeToCapture': 'begynder en opgave, med bogstavet i feltet',
 	'keys.navigation': 'Navigation',

web/src/lib/locales/en.js

@@ -372,6 +372,7 @@ export const en = {
 	'data.templatesHint':
 		'A project saved as a shape you can use again. The dates in a template are relative, so they are worked out from the start date you pick.',
 
+	'keys.foldSidebar': 'fold the sidebar away',
 	'keys.anyLetter': 'any letter',
 	'keys.typeToCapture': 'starts a task, with the letter already in the field',
 	'keys.navigation': 'Navigation',

web/src/lib/stores.svelte.js

@@ -156,6 +156,7 @@ class AppState {
 				break;
 			case 'task.deleted':
 				this.tasks = this.tasks.filter((t) => t.id !== task?.id);
+				this.refreshCounts();
 				break;
 
 			// Projects and labels belong to a person rather than to a project, so
@@ -246,6 +247,11 @@ class AppState {
 	 */
 	upsert(task) {
 		if (!task?.id) return;
+		// Before the branch, not after it. A task that is already in the list can
+		// still change the counts — moved to another project, finished in another
+		// tab, a recurring one that closed and opened itself — and the branch below
+		// returns early for exactly those.
+		this.refreshCounts();
 		if (this.tasks.some((t) => t.id === task.id)) {
 			this.replace(task.id, task);
 			return;
@@ -301,6 +307,7 @@ class AppState {
 		const what = task?.content ?? '';
 
 		await this.#optimistic(id, { completed: true }, () => api.completeTask(id));
+		this.refreshCounts();
 
 		if (!repeats) {
 			this.toast(t('task.completedUndo', { what: truncate(what) }), {
@@ -312,6 +319,7 @@ class AppState {
 
 	async reopen(id) {
 		await this.#optimistic(id, { completed: false }, () => api.reopenTask(id));
+		this.refreshCounts();
 	}
 
 	async update(id, patch) {
@@ -373,6 +381,7 @@ class AppState {
 		this.tasks = this.tasks.filter((t) => t.id !== id);
 		try {
 			await api.deleteTask(id);
+			this.refreshCounts();
 		} catch (e) {
 			this.tasks = previous;
 			this.toast(humanMessage(e));
@@ -417,6 +426,56 @@ class AppState {
 		this.projects = projects;
 	}
 
+	/**
+	 * Brings the sidebar's per-project counts back in line after tasks have moved.
+	 *
+	 * The count is open tasks now, which changes on every add, finish and delete —
+	 * where the old one, how many people are in it, changed about twice a year. It
+	 * would be quicker to add and subtract locally, and it would be wrong within a
+	 * day: a task moved between projects, one finished in another tab, a recurring
+	 * one that closed and reopened itself. Asking the server is one request and
+	 * cannot drift.
+	 *
+	 * Coalesced, because a paste of five tasks is five calls in the same tick and
+	 * the answer to all of them is the same.
+	 */
+	#countsRunning = false;
+	#countsAgain = false;
+	#countsTimer = null;
+
+	refreshCounts() {
+		// Two windows to coalesce over, not one. Collapsing calls that arrive within
+		// a tick is the easy half; the half that matters is a change arriving while
+		// the request is already in flight. Dropping those left the sidebar showing
+		// the count as it was one task ago, which is the state the test caught and
+		// which nothing but a reload would have corrected.
+		if (this.#countsRunning) {
+			this.#countsAgain = true;
+			return;
+		}
+		clearTimeout(this.#countsTimer);
+		this.#countsTimer = setTimeout(async () => {
+			this.#countsRunning = true;
+			try {
+				const { projects } = await api.listProjects();
+				const counts = new Map(projects.map((p) => [p.id, p.open_count]));
+				this.projects = this.projects.map((p) =>
+					counts.has(p.id) ? { ...p, open_count: counts.get(p.id) } : p
+				);
+			} catch {
+				// The number is a convenience; failing to update it must not put an
+				// error in front of somebody who was only ticking something off.
+			} finally {
+				this.#countsRunning = false;
+			}
+			if (this.#countsAgain) {
+				this.#countsAgain = false;
+				this.refreshCounts();
+			}
+		}, 120);
+	}
+
+
 	/**
 	 * Puts the projects in the given order.
 	 *

web/src/routes/+layout.svelte

@@ -60,6 +60,15 @@
 			paletteOpen = true;
 			return;
 		}
+		// Folding the sidebar had a button and nothing else, and a rectangle with a
+		// line down it is not a word: somebody who wanted the menu out of the way
+		// asked for the feature that was already there. ⌘B is where an editor puts
+		// it. Works while typing as well — it moves nothing in the field.
+		if ((event.metaKey || event.ctrlKey) && (event.key === 'b' || event.key === 'B')) {
+			event.preventDefault();
+			sidebar.toggle();
+			return;
+		}
 		if (typing || event.metaKey || event.ctrlKey || event.altKey) return;
 		if (app.detailId) return;
 
@@ -123,7 +132,7 @@
 					onclick={() => sidebar.toggle()}
 					aria-label={sidebar.collapsed ? t('nav.showSidebar') : t('nav.hideSidebar')}
 					aria-pressed={sidebar.collapsed}
-					title={sidebar.collapsed ? t('nav.showSidebar') : t('nav.hideSidebar')}
+					title={(sidebar.collapsed ? t('nav.showSidebar') : t('nav.hideSidebar')) + ' (⌘B)'}
 				>
 					<svg viewBox="0 0 24 24" aria-hidden="true">
 						<rect x="3" y="4" width="18" height="16" rx="2" />

web/src/routes/genveje/+page.svelte

@@ -14,7 +14,8 @@
 			title: t('keys.navigation'),
 			keys: [
 				[t('keys.anyLetter'), t('keys.typeToCapture')],
-				['⌘K / Ctrl+K', t('nav.search')]
+				['⌘K / Ctrl+K', t('nav.search')],
+				['⌘B / Ctrl+B', t('keys.foldSidebar')]
 			]
 		},
 		{