add tag listings, global and section-narrowed

One global namespace (ADR-0018): /tags/{term}/ spans every section and
/{section}/tags/{term}/ narrows it. Listings group by section so one busy term
stays readable, which needed List.Groups alongside Items — list.html renders
whichever is set.

This is Query's second use, so it gained a Tag field rather than being generalised
on speculation: one filter, two callers. Tag slugs lowercase and hyphenate,
preserving script, so "Long Monsoon" and "long monsoon" are one term while Bengali
passes through unchanged. Hand-chosen slugs per term still wait for the type
declaration that owns overrides.

`tags` is reserved at the top level and inside every section, alongside `page` and
the language prefixes. A tag listing redirects to its canonical URL only once it is
known to exist, matching the rule bundles already followed — otherwise a canonical
URL for nothing confirms what is not there.

One stale test expectation fixed rather than worked around: it asserted tags land
in Extra, which stopped being true when tags became a named field.

Evidence: /tags/monsoon/ lists Hello World under posts and First Rain under comics;
/comics/tags/monsoon/ shows one; /tags/monsoon 301s; /tags/nothing/ and /tags/ 404.

internal/web/resolve.go

@@ -14,6 +14,9 @@ type resolution struct {
 	lang string
 	// page is 1 for a bundle or the first listing page, higher for /page/N/.
 	page int
+	// tag is a tag slug when the path named a tag listing; key then holds the section, or "" for the
+	// global listing.
+	tag string
 	// redirect is the canonical path when the request named a non-canonical one. Non-empty means answer
 	// with a permanent redirect and nothing else.
 	redirect string
@@ -60,12 +63,35 @@ func resolve(path string, site *content.Site) (resolution, bool) {
 		}
 		key, page = rest, n
 	}
+	// tags/<term> at the top level, or <section>/tags/<term> inside one (ADR-0018). Recognised by shape
+	// here, so URL knowledge stays in the resolver.
+	tag, section, isTag := cutTag(key)
+
 	if !strings.HasSuffix(path, "/") {
+		if isTag {
+			return resolution{key: section, tag: tag, lang: lang, page: page,
+				redirect: content.TagURL(section, tag, lang, page)}, true
+		}
 		return resolution{key: key, lang: lang, page: page, redirect: content.PageURL(key, lang, page)}, true
 	}
+	if isTag {
+		return resolution{key: section, tag: tag, lang: lang, page: page}, true
+	}
 	return resolution{key: key, lang: lang, page: page}, true
 }
 
+// cutTag splits a tag listing key into its term and the section it is narrowed to.
+func cutTag(key string) (tag, section string, ok bool) {
+	if rest, found := strings.CutPrefix(key, content.TagsSegment+"/"); found {
+		return rest, "", rest != ""
+	}
+	if i := strings.Index(key, "/"+content.TagsSegment+"/"); i >= 0 {
+		term := key[i+len(content.TagsSegment)+2:]
+		return term, key[:i], term != ""
+	}
+	return "", "", false
+}
+
 // cutPage strips a trailing "page/N" off a key, reporting the page number.
 func cutPage(key string) (rest string, page int, ok bool) {
 	i := strings.LastIndex(key, "/")

internal/web/web.go

@@ -68,11 +68,41 @@ func serveListing(w http.ResponseWriter, req *http.Request, site *content.Site,
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return true
 	}
+	write(w, out, res.key)
+	return true
+}
+
+// serveTags answers a tag listing, grouped by section so a busy term stays readable (ADR-0018).
+func serveTags(w http.ResponseWriter, req *http.Request, site *content.Site, r *render.Renderer, res resolution) bool {
+	items := site.Run(content.Query{Section: res.key, Tag: res.tag, Lang: res.lang})
+	if len(items) == 0 {
+		return false
+	}
+	if res.page > 1 && (res.page-1)*content.PerPage >= len(items) {
+		return false
+	}
+	// Redirect only once the listing is known to exist, the same rule bundles follow: a canonical URL for
+	// nothing would confirm what is not there.
+	if res.redirect != "" {
+		http.Redirect(w, req, res.redirect, http.StatusMovedPermanently)
+		return true
+	}
+	out, err := r.Tag(res.key, res.tag, res.lang, items, res.page)
+	if err != nil {
+		slog.Error("tag listing failed", "tag", res.tag, "err", err)
+		http.Error(w, "internal error", http.StatusInternalServerError)
+		return true
+	}
+	write(w, out, res.tag)
+	return true
+}
+
+// write sends a rendered page, logging a failed write rather than pretending it succeeded.
+func write(w http.ResponseWriter, out []byte, what string) {
 	w.Header().Set("Content-Type", "text/html; charset=utf-8")
 	if _, err := w.Write(out); err != nil {
-		slog.Warn("write failed", "section", res.key, "err", err)
+		slog.Warn("write failed", "what", what, "err", err)
 	}
-	return true
 }
 
 // serve resolves one request and writes its bundle.
@@ -82,6 +112,12 @@ func serve(w http.ResponseWriter, req *http.Request, site *content.Site, r *rend
 		http.NotFound(w, req)
 		return
 	}
+	if res.tag != "" {
+		if !serveTags(w, req, site, r, res) {
+			http.NotFound(w, req)
+		}
+		return
+	}
 	// A redirect target only exists for a path that resolves, so check the bundle before sending one:
 	// otherwise a nonexistent page answers 301 and confirms nothing.
 	b, served, found := site.Lookup(res.key, res.lang)
@@ -110,8 +146,5 @@ func serve(w http.ResponseWriter, req *http.Request, site *content.Site, r *rend
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
-	w.Header().Set("Content-Type", "text/html; charset=utf-8")
-	if _, err := w.Write(out); err != nil {
-		slog.Warn("write failed", "key", b.Key, "err", err)
-	}
+	write(w, out, b.Key)
 }

internal/web/web_test.go

@@ -319,3 +319,68 @@ func TestStaticFilesAreServedAndDirectoriesAreNot(t *testing.T) {
 		}
 	}
 }
+
+func tagHandler(t *testing.T) http.Handler {
+	t.Helper()
+	fsys := fstest.MapFS{
+		"content/posts/essay.md": {Data: []byte("---\ntitle: Essay\ndate: 2026-01-03\ntags: [Monsoon]\n---\n")},
+		"content/comics/rain.md": {Data: []byte("---\ntitle: Rain\ndate: 2026-01-02\ntags: [monsoon]\n---\n")},
+		"content/posts/other.md": {Data: []byte("---\ntitle: Other\ndate: 2026-01-01\ntags: [prose]\n---\n")},
+	}
+	bundles, err := content.Scan(fsys)
+	if err != nil {
+		t.Fatal(err)
+	}
+	r, err := render.New(nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	return Handler(content.NewSite(bundles), r, nil)
+}
+
+func TestGlobalTagListingSpansSectionsGroupedByOne(t *testing.T) {
+	h := tagHandler(t)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/tags/monsoon/", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("got %d, want 200", rec.Code)
+	}
+	body := rec.Body.String()
+	for _, want := range []string{"<h2>posts</h2>", "<h2>comics</h2>", "Essay", "Rain"} {
+		if !strings.Contains(body, want) {
+			t.Errorf("missing %q — a tag spans sections and groups by one:\n%s", want, body)
+		}
+	}
+	if strings.Contains(body, "Other") {
+		t.Error("a different tag leaked in")
+	}
+}
+
+func TestSectionNarrowedTagListing(t *testing.T) {
+	h := tagHandler(t)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/comics/tags/monsoon/", nil))
+	if rec.Code != http.StatusOK {
+		t.Fatalf("got %d, want 200", rec.Code)
+	}
+	body := rec.Body.String()
+	if !strings.Contains(body, "Rain") || strings.Contains(body, "Essay") {
+		t.Errorf("narrowing to comics should drop the posts entry:\n%s", body)
+	}
+}
+
+func TestTagPathsCanonicaliseAndMiss(t *testing.T) {
+	h := tagHandler(t)
+	rec := httptest.NewRecorder()
+	h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, "/tags/monsoon", nil))
+	if rec.Code != http.StatusMovedPermanently || rec.Header().Get("Location") != "/tags/monsoon/" {
+		t.Errorf("slashless tag path = %d %q", rec.Code, rec.Header().Get("Location"))
+	}
+	for _, path := range []string{"/tags/nothing/", "/tags/", "/posts/tags/nothing/"} {
+		rec := httptest.NewRecorder()
+		h.ServeHTTP(rec, httptest.NewRequest(http.MethodGet, path, nil))
+		if rec.Code != http.StatusNotFound {
+			t.Errorf("GET %s = %d, want 404", path, rec.Code)
+		}
+	}
+}