Implementation plan: 14 TDD tasks for the lectio Go rewrite

1 files changed, 1378 insertions, 0 deletions

diff --git a/docs/superpowers/plans/2026-07-23-lectio-go-rewrite.md b/docs/superpowers/plans/2026-07-23-lectio-go-rewrite.md
new file mode 100644
index 0000000..84e5c32
--- /dev/null
+++ b/docs/superpowers/plans/2026-07-23-lectio-go-rewrite.md
@@ -0,0 +1,1378 @@
+# lectio Go Rewrite Implementation Plan
+
+> **For agentic workers:** REQUIRED SUB-SKILL: Use superpowers:subagent-driven-development (recommended) or superpowers:executing-plans to implement this plan task-by-task. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Reimplement the Python `daily-reading` tool as a self-contained Go project with two binaries — `lectio` (subcommand CLI) and `lectio-ui` (colored Bubble Tea TUI) — that fetches the daily Catholic readings and shows them across five versions with correct psalm versification, works offline from a harvested sigla file, and needs no external tools.
+
+**Architecture:** Thin front-ends (`cmd/lectio`, `cmd/lectio-ui`) over shared `internal/` packages: `bible` (embedded corpora + lookup + citation conversion), `psalter` (versification), `liturgy` (fetch/parse/cache/harvest/offline), `config`, `render` (text output), `cli`, `tui`. Modelled on `~/git/projects/bread-calc`.
+
+**Tech Stack:** Go 1.24, `github.com/charmbracelet/bubbletea` + `lipgloss` (TUI), `github.com/pelletier/go-toml/v2` (config). Stdlib `flag`, `net/http`, `embed`, `encoding/json` elsewhere.
+
+**Spec:** `docs/superpowers/specs/2026-07-23-lectio-go-rewrite-design.md` (read it before starting).
+
+## Global Constraints
+
+- Module path: `github.com/lukaszkasprzak/lectio`. Go directive: `go 1.24.0`.
+- No external runtime tools (no `vul`/`grb`/`wuj`/`drb`); all four corpora are embedded.
+- No CLI framework dependency (cobra etc.) — dispatch hand-rolled with stdlib `flag`.
+- Five version codes: `pl, wuj, vul, grb, drb`. Labels: `pl="Polski (niedziela.pl)"`, `wuj="Wujek (pol.)"`, `vul="Wulgata (lac.)"`, `grb="Grecki"`, `drb="Douay-Rheims (ang.)"`.
+- Psalm systems: `vul/grb/wuj` → `"vulgate"`, `drb` → `"drb"`. `pl` is not a bible-lookup version.
+- Cache dir: `${XDG_CACHE_HOME:-~/.cache}/lectio/`. Data dir (sigla): `${XDG_DATA_HOME:-~/.local/share}/lectio/sigla.tsv`. Config: `${XDG_CONFIG_HOME:-~/.config}/lectio/config.toml`.
+- Source URL: `https://niezbednik.niedziela.pl/liturgia/{date}/Ewangelia`. Dates are `YYYY-MM-DD`.
+- User-Agent: `Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0 Safari/537.36`.
+- Offline: `pl` is dropped and `wuj` takes the Polish role.
+- Exit codes: 0 ok, 1 runtime error, 2 usage error.
+- `gofmt`-formatted; `go vet ./...` clean. Commit after every task.
+
+---
+
+## File Structure
+
+```
+go.mod  go.sum  Makefile  .gitignore  README.md  LICENSE
+cmd/lectio/main.go              -> cli.Run(os.Args[1:], stdin, stdout, stderr)
+cmd/lectio-ui/main.go           -> load config, tui.New(...), tea program
+internal/psalter/psalter.go     DRB_TITLE_FOLD, DrbVerse, HebrewToVulgateChapter
+internal/bible/corpora/*.tsv    embedded wuj.tsv vul.tsv grb.tsv drb.tsv
+internal/bible/bible.go         Corpus, Load, Lookup, Verse
+internal/bible/books.go         canonical books, alias table, ResolveBook
+internal/bible/ref.go           ParseRef, SplitRef (reference grammar)
+internal/bible/convert.go       ToEnglishRef, psalmRef (Polish citation -> English)
+internal/liturgy/section.go     Section type, version constants/labels
+internal/liturgy/parse.go       Parse(html) []Section
+internal/liturgy/fetch.go       Fetch, cache (HTML+JSON), Load
+internal/liturgy/store.go       Harvest (update), sigla TSV, offline Load
+internal/liturgy/testdata/*.html fixtures
+internal/config/config.go       Config, Load, seed
+internal/render/render.go       GatherVersion, Compare, RenderSection, dedup
+internal/cli/cli.go             Run + subcommand dispatch
+internal/tui/styles.go          color role styles
+internal/tui/tui.go             Model, Init, Update, View
+```
+
+---
+
+## Task 1: Project scaffold + vendored corpora
+
+**Files:**
+- Create: `go.mod`, `Makefile`, `.gitignore`, `LICENSE`, `cmd/lectio/main.go`, `cmd/lectio-ui/main.go`
+- Create: `internal/bible/corpora/wuj.tsv`, `vul.tsv`, `grb.tsv`, `drb.tsv`
+
+**Interfaces:**
+- Produces: buildable module; `internal/cli.Run` and `internal/tui` referenced by mains (stubbed this task).
+
+- [ ] **Step 1: Init module and vendor corpora**
+
+```bash
+cd ~/git/projects/lectio
+cat > go.mod <<'EOF'
+module github.com/lukaszkasprzak/lectio
+
+go 1.24.0
+
+require (
+	github.com/charmbracelet/bubbletea v1.3.10
+	github.com/charmbracelet/lipgloss v1.1.0
+	github.com/pelletier/go-toml/v2 v2.4.2
+)
+EOF
+mkdir -p internal/bible/corpora cmd/lectio cmd/lectio-ui
+cp ~/git/projects/offline_readings/corpus/wuj.tsv internal/bible/corpora/wuj.tsv
+cp ~/git/projects/offline_readings/drb/drb.tsv   internal/bible/corpora/drb.tsv
+sed '1,/^#EOF$/d' "$(command -v vul)" | tar xzf - -O vul.tsv > internal/bible/corpora/vul.tsv
+sed '1,/^#EOF$/d' "$(command -v grb)" | tar xzf - -O grb.tsv > internal/bible/corpora/grb.tsv
+# grb.tsv has a UTF-8 BOM on line 1; strip it
+sed -i '1s/^\xEF\xBB\xBF//' internal/bible/corpora/grb.tsv
+wc -l internal/bible/corpora/*.tsv
+```
+
+Expected: four files, ~31k–35k lines each.
+
+- [ ] **Step 2: Stub the two mains so the tree builds**
+
+`cmd/lectio/main.go`:
+```go
+package main
+
+import (
+	"os"
+
+	"github.com/lukaszkasprzak/lectio/internal/cli"
+)
+
+func main() {
+	os.Exit(cli.Run(os.Args[1:], os.Stdin, os.Stdout, os.Stderr))
+}
+```
+
+`internal/cli/cli.go` (temporary stub, replaced in Task 12):
+```go
+package cli
+
+import (
+	"fmt"
+	"io"
+)
+
+// Run is the CLI entry point; returns a process exit code.
+func Run(args []string, stdin io.Reader, stdout, stderr io.Writer) int {
+	fmt.Fprintln(stdout, "lectio: not yet implemented")
+	return 0
+}
+```
+
+`cmd/lectio-ui/main.go` (temporary stub, replaced in Task 15):
+```go
+package main
+
+import "fmt"
+
+func main() { fmt.Println("lectio-ui: not yet implemented") }
+```
+
+- [ ] **Step 3: Makefile, .gitignore, LICENSE**
+
+`Makefile` (adapt bread-calc's):
+```make
+LECTIO    := lectio
+LECTIO_UI := lectio-ui
+PREFIX   ?= $(HOME)/.local
+BINDIR   := $(PREFIX)/bin
+
+.PHONY: help build install uninstall test vet fmt clean cross
+help: ## show this help
+	@grep -hE '^[a-z-]+:.*##' $(MAKEFILE_LIST) | sed -E 's/:.*## /\t/' | sort
+build: ## build ./lectio and ./lectio-ui
+	go build -o $(LECTIO) ./cmd/lectio
+	go build -o $(LECTIO_UI) ./cmd/lectio-ui
+install: ## build and install both to $(BINDIR)
+	@mkdir -p $(BINDIR)
+	go build -o $(BINDIR)/$(LECTIO) ./cmd/lectio
+	go build -o $(BINDIR)/$(LECTIO_UI) ./cmd/lectio-ui
+	@echo "installed $(BINDIR)/$(LECTIO) and $(BINDIR)/$(LECTIO_UI)"
+uninstall: ## remove installed binaries
+	rm -f $(BINDIR)/$(LECTIO) $(BINDIR)/$(LECTIO_UI)
+test: ## run tests
+	go test ./...
+vet: ## go vet
+	go vet ./...
+fmt: ## gofmt the tree
+	gofmt -w .
+clean: ## remove build artifacts
+	rm -f $(LECTIO) $(LECTIO_UI); rm -rf dist
+cross: ## cross-compile into dist/
+	@mkdir -p dist
+	@for t in linux/amd64 linux/arm64 darwin/arm64 darwin/amd64 windows/amd64; do \
+		os=$${t%/*}; arch=$${t#*/}; ext=; [ $$os = windows ] && ext=.exe; \
+		echo "  $$os/$$arch"; \
+		GOOS=$$os GOARCH=$$arch go build -o dist/$(LECTIO)-$$os-$$arch$$ext ./cmd/lectio; \
+		GOOS=$$os GOARCH=$$arch go build -o dist/$(LECTIO_UI)-$$os-$$arch$$ext ./cmd/lectio-ui; \
+	done
+```
+
+`.gitignore`:
+```
+/lectio
+/lectio-ui
+dist/
+*.test
+*.out
+coverage.*
+```
+
+`LICENSE`: copy `~/git/projects/bread-calc/LICENSE` verbatim.
+
+- [ ] **Step 4: Fetch deps and build**
+
+Run:
+```bash
+go mod tidy
+go build ./cmd/lectio ./cmd/lectio-ui && ./lectio
+```
+Expected: `go.sum` written; build succeeds; prints `lectio: not yet implemented`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add -A && git commit -m "scaffold: module, mains, Makefile, embedded corpora"
+```
+
+---
+
+## Task 2: internal/psalter (versification port)
+
+**Files:**
+- Create: `internal/psalter/psalter.go`, `internal/psalter/psalter_test.go`
+- Source: port `~/git/projects/daily-reading/psalm_versify.py` verbatim.
+
+**Interfaces:**
+- Produces: `psalter.DrbVerse(hebrewPsalm, lectionaryVerse int) int`; `psalter.HebrewToVulgateChapter(h int) int`; `psalter.DRBTitleFold map[int]int`.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/psalter/psalter_test.go`:
+```go
+package psalter
+
+import "testing"
+
+func TestDrbVerse(t *testing.T) {
+	cases := []struct{ psalm, v, want int }{
+		{34, 2, 1},   // Ps 34: k=1, title folded
+		{34, 3, 2},
+		{51, 3, 1},   // Ps 51: k=2 (two-line title)
+		{63, 2, 1},   // Ps 63: k=1
+		{1, 5, 5},    // untitled: identity
+		{34, 1, 1},   // clamp: never below 1
+	}
+	for _, c := range cases {
+		if got := DrbVerse(c.psalm, c.v); got != c.want {
+			t.Errorf("DrbVerse(%d,%d)=%d want %d", c.psalm, c.v, got, c.want)
+		}
+	}
+}
+
+func TestHebrewToVulgateChapter(t *testing.T) {
+	cases := []struct{ h, want int }{{8, 8}, {34, 33}, {9, 9}, {10, 9}, {116, 114}, {147, 146}, {150, 150}}
+	for _, c := range cases {
+		if got := HebrewToVulgateChapter(c.h); got != c.want {
+			t.Errorf("HebrewToVulgateChapter(%d)=%d want %d", c.h, got, c.want)
+		}
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/psalter/` — Expected: FAIL (undefined: DrbVerse).
+
+- [ ] **Step 3: Implement psalter.go**
+
+Port the data and functions from `psalm_versify.py`. `DRBTitleFold` is the exact `DRB_TITLE_FOLD` dict (63 entries) rendered as a Go map literal; `DrbVerse` and `HebrewToVulgateChapter` mirror the Python functions.
+
+`internal/psalter/psalter.go`:
+```go
+// Package psalter bridges psalm versification between the Vulgate-family
+// versions and the Douay-Rheims source. See the Go port of psalm_versify.py.
+package psalter
+
+// DRBTitleFold maps a Hebrew psalm number to the number of title verses the DRB
+// source folds into verse 1 (1, or 2 for a historical superscription). Untitled
+// psalms are absent (k = 0). Copy every entry from psalm_versify.py DRB_TITLE_FOLD.
+var DRBTitleFold = map[int]int{
+	3: 1, 4: 1, 5: 1, 6: 1, 7: 1, 8: 1, 11: 1, 12: 1, 14: 1, 18: 1, 19: 1,
+	20: 1, 21: 1, 22: 1, 30: 1, 31: 1, 34: 1, 36: 1, 38: 1, 39: 1, 40: 1,
+	41: 1, 42: 1, 44: 1, 45: 1, 46: 1, 47: 1, 48: 1, 49: 1, 51: 2, 52: 2,
+	53: 1, 54: 2, 55: 1, 56: 1, 57: 1, 58: 1, 59: 1, 60: 2, 61: 1, 62: 1,
+	63: 1, 64: 1, 65: 1, 67: 1, 68: 1, 69: 1, 70: 1, 75: 1, 76: 1, 77: 1,
+	80: 1, 81: 1, 83: 1, 84: 1, 85: 1, 88: 1, 89: 1, 92: 1, 102: 1, 108: 1,
+	140: 1, 142: 1,
+}
+
+// DrbVerse returns the DRB-source verse number for a lectionary (BT) psalm verse.
+func DrbVerse(hebrewPsalm, lectionaryVerse int) int {
+	v := lectionaryVerse - DRBTitleFold[hebrewPsalm]
+	if v < 1 {
+		return 1
+	}
+	return v
+}
+
+// HebrewToVulgateChapter maps a Masoretic psalm number to its Vulgate chapter.
+func HebrewToVulgateChapter(h int) int {
+	switch {
+	case h <= 8 || h >= 148:
+		return h
+	case h >= 9 && h <= 10:
+		return 9
+	case h >= 11 && h <= 113:
+		return h - 1
+	case h >= 114 && h <= 115:
+		return 113
+	case h == 116:
+		return 114
+	case h >= 117 && h <= 146:
+		return h - 1
+	case h == 147:
+		return 146
+	}
+	return h
+}
+```
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/psalter/` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/psalter && git commit -m "psalter: port psalm versification"
+```
+
+---
+
+## Task 3: internal/bible — canonical books + alias resolution
+
+**Files:**
+- Create: `internal/bible/books.go`, `internal/bible/books_test.go`
+- Source: port book names/abbrevs from the four corpora and the alias table from `~/git/projects/offline_readings/corpus/book_aliases.py` + `~/git/projects/daily-reading/ewangelia.py` `POLISH_TO_EN`.
+
+**Interfaces:**
+- Produces: `bible.ResolveBook(query string) (canonical string, ok bool)` — resolves an English name, English prefix, or Polish alias to a canonical English book name (as used in the corpora, e.g. `"John"`, `"1 Corinthians"`, `"The Acts"`, `"Song of Solomon"`, `"Wisdom"`).
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/bible/books_test.go`:
+```go
+package bible
+
+import "testing"
+
+func TestResolveBook(t *testing.T) {
+	cases := []struct{ in, want string }{
+		{"John", "John"},
+		{"Joh", "John"},          // English prefix
+		{"J", "John"},            // Polish abbrev — NOT Joshua
+		{"Łk", "Luke"},
+		{"1 Kor", "1 Corinthians"},
+		{"Jana", "John"},
+		{"Rodzaju", "Genesis"},
+		{"Mdr", "Wisdom"},
+		{"Pnp", "Song of Solomon"},
+		{"Dz", "The Acts"},
+	}
+	for _, c := range cases {
+		if got, ok := ResolveBook(c.in); !ok || got != c.want {
+			t.Errorf("ResolveBook(%q)=%q,%v want %q", c.in, got, ok, c.want)
+		}
+	}
+	if _, ok := ResolveBook("Nonsense"); ok {
+		t.Error("ResolveBook(Nonsense) should fail")
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/bible/ -run TestResolveBook` — Expected: FAIL (undefined: ResolveBook).
+
+- [ ] **Step 3: Implement books.go**
+
+Build an alias→canonical map. Resolution order (deterministic, fixes `J`→John): (1) exact alias match (longest alias wins for multi-word), (2) exact canonical name, (3) canonical-name prefix (len ≥ 2). Port the alias sets verbatim from `book_aliases.py` `BOOKS` (73 books incl. deuterocanonicals; each entry's aliases plus the canonical name). Generate case variants (original, lower, upper) at init as `book_aliases.py` does.
+
+`internal/bible/books.go` (structure — fill `aliasSeed` from `book_aliases.py`):
+```go
+package bible
+
+import "strings"
+
+// canonical English book names, in corpus form.
+// aliasSeed maps a canonical name to its accepted aliases (Polish abbrev, Polish
+// full name, English abbrev). COPY every entry from offline_readings book_aliases.py.
+var aliasSeed = map[string][]string{
+	"Genesis":         {"Rdz", "Rodzaju", "Gen"},
+	"Exodus":          {"Wj", "Wyjścia", "Ex", "Exod"},
+	// ... all 73 books, verbatim from book_aliases.py ...
+	"John":            {"J", "Jan", "Jana"},
+	"1 Corinthians":   {"1 Kor", "1 Koryntian"},
+	"Song of Solomon": {"Pnp", "Pieśń nad Pieśniami"},
+	"The Acts":        {"Dz", "Dzieje", "Dzieje Apostolskie", "Acts"},
+	"Wisdom":          {"Mdr", "Mądrości", "Księga Mądrości"},
+	"Revelation":      {"Ap", "Apokalipsa", "Objawienie"},
+}
+
+var aliasMap map[string]string // lowercased alias -> canonical
+var canonical []string         // canonical names for prefix matching
+
+func init() {
+	aliasMap = map[string]string{}
+	seen := map[string]bool{}
+	for name, aliases := range aliasSeed {
+		canonical = append(canonical, name)
+		for _, a := range append([]string{name}, aliases...) {
+			k := strings.ToLower(a)
+			if !seen[k] {
+				seen[k] = true
+				aliasMap[k] = name
+			}
+		}
+	}
+}
+
+// ResolveBook maps an English name/prefix or a Polish alias to a canonical book.
+func ResolveBook(query string) (string, bool) {
+	q := strings.ToLower(strings.TrimSpace(query))
+	if c, ok := aliasMap[q]; ok { // exact alias/name
+		return c, true
+	}
+	for _, name := range canonical { // canonical prefix, len>=2
+		if len(q) >= 2 && strings.HasPrefix(strings.ToLower(name), q) {
+			return name, true
+		}
+	}
+	return "", false
+}
+```
+
+Note: the alias map's exact match runs before prefix, so `"j"` resolves via alias to `John` and never prefix-matches `Joshua`.
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/bible/ -run TestResolveBook` — Expected: PASS. If `J`→Joshua, the alias for John is missing; verify `aliasSeed["John"]` contains `"J"`.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/bible/books.go internal/bible/books_test.go
+git commit -m "bible: canonical books + alias resolution"
+```
+
+---
+
+## Task 4: internal/bible — embedded corpora + Lookup
+
+**Files:**
+- Create: `internal/bible/bible.go`, `internal/bible/bible_test.go`
+
+**Interfaces:**
+- Consumes: `ResolveBook` (Task 3).
+- Produces: `bible.Verse{Chapter, Verse int; Text string}`; `bible.Lookup(version, book string, groups []VerseGroup) ([]Verse, []string)` where `VerseGroup` is defined in Task 5. **This task provides the corpus store + a simpler `lookupBook(version, book string) (map[[2]int]string, []int, bool)` helper**; the group-aware `Lookup` is completed in Task 5. Split accordingly: here, deliver corpus loading + a `Verses(version, book, chap int) []Verse` accessor.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/bible/bible_test.go`:
+```go
+package bible
+
+import "testing"
+
+func TestVerses(t *testing.T) {
+	cases := []struct {
+		version, book string
+		chap, verse   int
+		wantPrefix    string
+	}{
+		{"wuj", "Genesis", 1, 1, "Na początku stworzył Bóg"},
+		{"vul", "Genesis", 1, 1, "In principio creavit Deus"},
+		{"drb", "John", 20, 1, "AND on the first day of the week"},
+		{"wuj", "Wisdom", 3, 1, "A dusze sprawiedliwych"}, // deuterocanonical
+	}
+	for _, c := range cases {
+		vs := Verses(c.version, c.book, c.chap)
+		var got string
+		for _, v := range vs {
+			if v.Verse == c.verse {
+				got = v.Text
+			}
+		}
+		if !hasPrefix(got, c.wantPrefix) {
+			t.Errorf("%s %s %d:%d = %q want prefix %q", c.version, c.book, c.chap, c.verse, got, c.wantPrefix)
+		}
+	}
+}
+
+func hasPrefix(s, p string) bool { return len(s) >= len(p) && s[:len(p)] == p }
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/bible/ -run TestVerses` — Expected: FAIL (undefined: Verses).
+
+- [ ] **Step 3: Implement bible.go**
+
+Embed the four TSVs; parse each once (lazy, `sync.Once`) into `map[book]map[chap][]Verse`.
+
+```go
+package bible
+
+import (
+	"embed"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+//go:embed corpora/wuj.tsv corpora/vul.tsv corpora/grb.tsv corpora/drb.tsv
+var corporaFS embed.FS
+
+// Verse is a single verse.
+type Verse struct {
+	Chapter, Verse int
+	Text           string
+}
+
+type corpus struct {
+	books map[string]map[int][]Verse // book -> chapter -> verses (verse-ordered)
+}
+
+var (
+	corpora   = map[string]*corpus{}
+	corporaMu sync.Mutex
+)
+
+func load(version string) *corpus {
+	corporaMu.Lock()
+	defer corporaMu.Unlock()
+	if c, ok := corpora[version]; ok {
+		return c
+	}
+	data, err := corporaFS.ReadFile("corpora/" + version + ".tsv")
+	if err != nil {
+		corpora[version] = &corpus{books: map[string]map[int][]Verse{}}
+		return corpora[version]
+	}
+	c := &corpus{books: map[string]map[int][]Verse{}}
+	for _, line := range strings.Split(string(data), "\n") {
+		f := strings.Split(line, "\t")
+		if len(f) != 6 {
+			continue
+		}
+		chap, _ := strconv.Atoi(f[3])
+		vn, _ := strconv.Atoi(f[4])
+		book := f[0]
+		if c.books[book] == nil {
+			c.books[book] = map[int][]Verse{}
+		}
+		c.books[book][chap] = append(c.books[book][chap], Verse{chap, vn, f[5]})
+	}
+	corpora[version] = c
+	return c
+}
+
+// Verses returns all verses of one chapter of a book in a version (may be empty).
+func Verses(version, book string, chap int) []Verse {
+	return load(version).books[book][chap]
+}
+```
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/bible/ -run TestVerses` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/bible/bible.go internal/bible/bible_test.go
+git commit -m "bible: embed corpora + chapter lookup"
+```
+
+---
+
+## Task 5: internal/bible — reference grammar (ParseRef, SplitRef, Lookup)
+
+**Files:**
+- Create: `internal/bible/ref.go`, `internal/bible/ref_test.go`
+
+**Interfaces:**
+- Consumes: `ResolveBook`, `Verses`.
+- Produces:
+  - `type VerseGroup struct{ Chapter, From, To int }` (To==From for a single verse; a whole-verse-list "20:1,2,3" is multiple groups).
+  - `SplitRef(ref string) []string` — split a kjv-style ref with a mixed comma/range list into single-group refs (port of Python `split_ref`).
+  - `Lookup(version, ref string) (verses []Verse, missing []string)` — resolve a full English-style ref (`"John 20:1,11-18"`), returning matched verses in order and the sub-refs the corpus lacked.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/bible/ref_test.go`:
+```go
+package bible
+
+import "testing"
+
+func TestSplitRef(t *testing.T) {
+	got := SplitRef("John 20:1,11-18")
+	want := []string{"John 20:1", "John 20:11-18"}
+	if len(got) != 2 || got[0] != want[0] || got[1] != want[1] {
+		t.Fatalf("SplitRef mixed = %v want %v", got, want)
+	}
+	if g := SplitRef("Mat 7:1-5"); len(g) != 1 || g[0] != "Mat 7:1-5" {
+		t.Errorf("SplitRef contiguous = %v", g)
+	}
+}
+
+func TestLookup(t *testing.T) {
+	vs, missing := Lookup("wuj", "John 20:1,11-18")
+	if len(missing) != 0 {
+		t.Fatalf("missing = %v", missing)
+	}
+	if len(vs) == 0 || vs[0].Verse != 1 {
+		t.Fatalf("first verse = %+v", vs)
+	}
+	last := vs[len(vs)-1]
+	if last.Verse != 18 {
+		t.Errorf("last verse = %d want 18", last.Verse)
+	}
+	if _, m := Lookup("vul", "Wisdom 3:1"); len(m) == 0 {
+		t.Error("vul lacks Wisdom; expected a missing entry")
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/bible/ -run 'TestSplitRef|TestLookup'` — Expected: FAIL.
+
+- [ ] **Step 3: Implement ref.go**
+
+Port `split_ref` and the reference-parsing logic. A ref is `<book> <chap>:<verses>` where `<verses>` is a comma list of items, each a single verse or a `from-to` range. `SplitRef` groups a mixed list (single verses + ranges) into separate refs, mirroring Python. `Lookup` resolves the book, then for each `SplitRef` part parses the chapter/range, pulls from `Verses`, and records misses.
+
+```go
+package bible
+
+import (
+	"regexp"
+	"strconv"
+	"strings"
+)
+
+var refRe = regexp.MustCompile(`^(.*?)\s+(\d+):(.+)$`)
+
+// SplitRef splits a ref whose verse list mixes single verses and ranges into
+// one ref per group (the kjv tools reject a mixed list in a single query).
+func SplitRef(ref string) []string {
+	m := refRe.FindStringSubmatch(ref)
+	if m == nil {
+		return []string{ref}
+	}
+	book, chap, verses := m[1], m[2], m[3]
+	if !strings.Contains(verses, ",") {
+		return []string{ref}
+	}
+	var out []string
+	for _, g := range strings.Split(verses, ",") {
+		g = strings.TrimSpace(g)
+		if g == "" {
+			continue
+		}
+		if strings.Contains(g, ":") {
+			out = append(out, book+" "+g)
+		} else {
+			out = append(out, book+" "+chap+":"+g)
+		}
+	}
+	return out
+}
+
+// Lookup resolves an English-style reference against a version, returning the
+// matched verses (in order) and the sub-refs the corpus had no entry for.
+func Lookup(version, ref string) ([]Verse, []string) {
+	var verses []Verse
+	var missing []string
+	for _, part := range SplitRef(ref) {
+		m := refRe.FindStringSubmatch(part)
+		if m == nil {
+			missing = append(missing, part)
+			continue
+		}
+		book, ok := ResolveBook(m[1])
+		if !ok {
+			missing = append(missing, part)
+			continue
+		}
+		chap, _ := strconv.Atoi(m[2])
+		from, to := verseRange(m[3])
+		found := false
+		for _, v := range Verses(version, book, chap) {
+			if v.Verse >= from && v.Verse <= to {
+				verses = append(verses, v)
+				found = true
+			}
+		}
+		if !found {
+			missing = append(missing, part)
+		}
+	}
+	return verses, missing
+}
+
+func verseRange(s string) (int, int) {
+	s = strings.TrimSpace(s)
+	if i := strings.IndexAny(s, "-–—"); i >= 0 {
+		from, _ := strconv.Atoi(strings.TrimSpace(s[:i]))
+		to, _ := strconv.Atoi(strings.TrimSpace(s[i+1:]))
+		return from, to
+	}
+	n, _ := strconv.Atoi(s)
+	return n, n
+}
+```
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/bible/ -run 'TestSplitRef|TestLookup'` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/bible/ref.go internal/bible/ref_test.go
+git commit -m "bible: reference grammar + Lookup"
+```
+
+---
+
+## Task 6: internal/bible — Polish citation → English ref conversion
+
+**Files:**
+- Create: `internal/bible/convert.go`, `internal/bible/convert_test.go`
+- Source: port `to_english_ref` / `_psalm_ref` and `POLISH_TO_EN` from `~/git/projects/daily-reading/ewangelia.py`.
+
+**Interfaces:**
+- Consumes: `psalter.DrbVerse`.
+- Produces: `bible.ToEnglishRef(plCitation, system string) (string, error)` where `system` ∈ `"vulgate"`, `"drb"`. Converts a Polish citation (`"Mt 7, 1-5"`, `"por. J 20, 11"`, `"Ps 63 (62), 2. 3-4 (R.: por. 2ab)"`) to a kjv-style ref.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/bible/convert_test.go`:
+```go
+package bible
+
+import "testing"
+
+func TestToEnglishRef(t *testing.T) {
+	cases := []struct{ in, system, want string }{
+		{"Mt 7, 1-5", "vulgate", "Mat 7:1-5"},
+		{"J 20, 1. 11-18", "vulgate", "John 20:1,11-18"},
+		{"por. J 20, 11", "vulgate", "John 20:11"},
+		{"Ps 63 (62), 2. 3-4. 5-6. 8-9 (R.: por. 2ab)", "vulgate", "Psalms 62:2,3-4,5-6,8-9"},
+		{"Ps 63 (62), 2. 3-4. 5-6. 8-9 (R.: por. 2ab)", "drb", "Psalms 63:1,2-3,4-5,7-8"},
+	}
+	for _, c := range cases {
+		got, err := ToEnglishRef(c.in, c.system)
+		if err != nil || got != c.want {
+			t.Errorf("ToEnglishRef(%q,%q)=%q,%v want %q", c.in, c.system, got, err, c.want)
+		}
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/bible/ -run TestToEnglishRef` — Expected: FAIL.
+
+- [ ] **Step 3: Implement convert.go**
+
+Port `POLISH_TO_EN` (the full dict from `ewangelia.py`, ~66 entries — note it maps to short gospel forms `Mt→Mat` etc.), `to_english_ref`, and `_psalm_ref`. Steps mirror the Python exactly: strip leading `por.`, strip trailing `(R.: ...)`, collapse whitespace, match the longest Polish book key, for Psalms route through `psalmRef` (dual-numbering pick + drb verse fold via `psalter.DrbVerse`), then the punctuation transforms (`, `→`:`, `. `→`,`, ` i `→`,`, ranges, drop verse-part letters, remove spaces).
+
+Provide the full function bodies (translated line-for-line from the Python). Key psalm helper:
+```go
+// psalmRef maps the psalm citation body ("63 (62), 2. 3-4. ...") to the target Psalter.
+func psalmRef(rest, system string) string {
+	m := regexp.MustCompile(`(\d+)(?:\s*\((\d+)\))?(.*)$`).FindStringSubmatch(rest)
+	if m == nil {
+		return rest
+	}
+	heb, _ := strconv.Atoi(m[1])
+	tail := m[3]
+	if system == "vulgate" {
+		ch := m[1]
+		if m[2] != "" {
+			ch = m[2]
+		}
+		return ch + tail
+	}
+	if system == "drb" {
+		tail = regexp.MustCompile(`\d+`).ReplaceAllStringFunc(tail, func(s string) string {
+			n, _ := strconv.Atoi(s)
+			return strconv.Itoa(psalter.DrbVerse(heb, n))
+		})
+	}
+	return strconv.Itoa(heb) + tail
+}
+```
+`ToEnglishRef` returns an `error` when no Polish book matches (mirrors the Python `ValueError`).
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/bible/` — Expected: PASS (all bible tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/bible/convert.go internal/bible/convert_test.go
+git commit -m "bible: Polish citation -> English ref (with psalm versification)"
+```
+
+---
+
+## Task 7: internal/liturgy — Section type + Parse
+
+**Files:**
+- Create: `internal/liturgy/section.go`, `internal/liturgy/parse.go`, `internal/liturgy/parse_test.go`
+- Create fixtures: `internal/liturgy/testdata/2026-07-22.html` (split feast), `2026-06-22.html` (normal day). Copy from `~/.cache/daily-reading/`.
+
+**Interfaces:**
+- Produces: `liturgy.Section{Heading, Subtitle, Citation string; Paragraphs [][]string}`; `liturgy.Parse(html string) ([]Section, error)`; `liturgy.ExtractCitation(heading string) (string, error)`.
+
+- [ ] **Step 1: Copy fixtures + write the failing test**
+
+```bash
+mkdir -p internal/liturgy/testdata
+cp ~/.cache/daily-reading/2026-07-22.html internal/liturgy/testdata/
+cp ~/.cache/daily-reading/2026-06-22.html internal/liturgy/testdata/
+```
+
+`internal/liturgy/parse_test.go`:
+```go
+package liturgy
+
+import (
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestParse(t *testing.T) {
+	html, _ := os.ReadFile("testdata/2026-07-22.html")
+	secs, err := Parse(string(html))
+	if err != nil {
+		t.Fatal(err)
+	}
+	var gospel *Section
+	for i := range secs {
+		if strings.HasPrefix(secs[i].Heading, "Ewangelia") {
+			gospel = &secs[i]
+		}
+	}
+	if gospel == nil {
+		t.Fatal("no gospel section")
+	}
+	if gospel.Citation != "J 20, 1. 11-18" {
+		t.Errorf("gospel citation = %q", gospel.Citation)
+	}
+	if len(gospel.Paragraphs) == 0 {
+		t.Error("gospel has no paragraphs")
+	}
+}
+
+func TestParseLayoutChange(t *testing.T) {
+	if _, err := Parse("<html><body>redesigned</body></html>"); err == nil {
+		t.Error("expected error on missing reading tab")
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/liturgy/ -run TestParse` — Expected: FAIL (undefined: Parse).
+
+- [ ] **Step 3: Implement section.go + parse.go**
+
+Port `parse_sections`, `html_to_lines`, `extract_reference` from `ewangelia.py`. Prefer the `tabnowy0all` tab; fall back to `tabstary0all`; error if neither, or if found-but-empty. Use `regexp` and `html.UnescapeString`. `ExtractCitation` pulls the parenthetical from a heading.
+
+Provide full Go translations. Key regexes: pane `<div class="tab-pane[^"]*"\s+id="%s">`, headings `<h2>(.*?)</h2>` (with `(?s)`), subtitle `<h4>(.*?)</h4>`, paragraphs `<p>(.*?)</p>`, `<br\s*/?>` → newline, strip `<[^>]+>`.
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/liturgy/ -run TestParse` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/liturgy/section.go internal/liturgy/parse.go internal/liturgy/parse_test.go internal/liturgy/testdata
+git commit -m "liturgy: Section type + HTML parse (fixtures)"
+```
+
+---
+
+## Task 8: internal/liturgy — Fetch + cache + Load
+
+**Files:**
+- Create: `internal/liturgy/fetch.go`, `internal/liturgy/fetch_test.go`
+
+**Interfaces:**
+- Consumes: `Parse`.
+- Produces:
+  - `type Options struct{ Date string; Refresh, Offline bool }`
+  - `liturgy.Load(opts Options) ([]Section, error)` — JSON cache → HTML cache(+parse, write JSON) → fetch(+cache both). (Offline path added in Task 9.)
+  - `liturgy.cacheDir() string`, using `XDG_CACHE_HOME`.
+
+- [ ] **Step 1: Write the failing test (cache round-trip via a local server)**
+
+`internal/liturgy/fetch_test.go`:
+```go
+package liturgy
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"testing"
+)
+
+func TestLoadCaches(t *testing.T) {
+	html, _ := os.ReadFile("testdata/2026-06-22.html")
+	hits := 0
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		hits++
+		w.Write(html)
+	}))
+	defer srv.Close()
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	baseURL = srv.URL + "/liturgia/%s/Ewangelia" // test hook
+
+	secs1, err := Load(Options{Date: "2026-06-22"})
+	if err != nil || len(secs1) == 0 {
+		t.Fatalf("load1: %v", err)
+	}
+	secs2, _ := Load(Options{Date: "2026-06-22"}) // should hit JSON cache
+	if hits != 1 {
+		t.Errorf("server hit %d times, want 1 (cache miss on repeat)", hits)
+	}
+	if len(secs2) != len(secs1) {
+		t.Error("cache returned different section count")
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/liturgy/ -run TestLoadCaches` — Expected: FAIL.
+
+- [ ] **Step 3: Implement fetch.go**
+
+`baseURL` is a package var (default the real URL, overridable in tests). `Load`: compute cache paths; if not `Refresh`, try `{date}.json` (unmarshal `[]Section`); else try `{date}.html` (parse, write JSON); else GET `baseURL` with the User-Agent, and — only if the page is fully published (`id="\w*0all"` present) — write `{date}.html` and `{date}.json`. Publish detection and the "Przykro nam"/unpublished handling mirror `ewangelia.py`.
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/liturgy/ -run TestLoadCaches` — Expected: PASS (`hits == 1`).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/liturgy/fetch.go internal/liturgy/fetch_test.go
+git commit -m "liturgy: fetch + HTML/JSON cache"
+```
+
+---
+
+## Task 9: internal/liturgy — sigla harvest + offline Load
+
+**Files:**
+- Create: `internal/liturgy/store.go`, `internal/liturgy/store_test.go`
+- Modify: `internal/liturgy/fetch.go` (Load consults offline path when `opts.Offline`)
+
+**Interfaces:**
+- Produces:
+  - `liturgy.Harvest(fromDate string, maxDays int) (added int, furthest string, err error)` — walks dates, extracts citations, writes/merges the sigla TSV. Stops at the unpublished horizon.
+  - `liturgy.LoadOffline(date string) ([]Section, error)` — build sections from the sigla TSV (Citation set, Paragraphs empty).
+  - `liturgy.siglaPath() string` (`XDG_DATA_HOME`).
+- Modify `Load`: when `opts.Offline`, return `LoadOffline(opts.Date)`.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/liturgy/store_test.go`:
+```go
+package liturgy
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"os"
+	"strings"
+	"testing"
+)
+
+func TestHarvestAndOffline(t *testing.T) {
+	html, _ := os.ReadFile("testdata/2026-07-22.html")
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if strings.Contains(r.URL.Path, "2026-07-22") {
+			w.Write(html)
+		} else {
+			w.Write([]byte("<html>Przykro nam</html>")) // horizon
+		}
+	}))
+	defer srv.Close()
+	t.Setenv("XDG_CACHE_HOME", t.TempDir())
+	t.Setenv("XDG_DATA_HOME", t.TempDir())
+	baseURL = srv.URL + "/liturgia/%s/Ewangelia"
+
+	added, _, err := Harvest("2026-07-22", 3)
+	if err != nil || added < 1 {
+		t.Fatalf("harvest: added=%d err=%v", added, err)
+	}
+	secs, err := LoadOffline("2026-07-22")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var haveGospel bool
+	for _, s := range secs {
+		if s.Citation == "J 20, 1. 11-18" {
+			haveGospel = true
+		}
+	}
+	if !haveGospel {
+		t.Error("offline gospel citation missing")
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/liturgy/ -run TestHarvestAndOffline` — Expected: FAIL.
+
+- [ ] **Step 3: Implement store.go + modify Load**
+
+`Harvest`: from `fromDate`, for up to `maxDays` (0 = until horizon), fetch+parse each date; on "no reading published"/parse error, stop (horizon). For each section, `ExtractCitation` → append rows `date\tlabel\tcitation`. Merge with existing TSV (replace a date's rows on re-harvest). `LoadOffline`: read the TSV, gather rows for the date, build `[]Section{Heading:label, Citation:citation}`. Date iteration uses `time.Parse("2006-01-02", ...)` + `AddDate(0,0,1)`. In `Load`: add `if opts.Offline { return LoadOffline(opts.Date) }` at the top; and wrap the network branch so that on a fetch error it falls back to `LoadOffline(opts.Date)` when the date is harvested, returning the original fetch error only if the offline load also fails (auto-fallback per the spec).
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/liturgy/` — Expected: PASS (all liturgy tests).
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/liturgy/store.go internal/liturgy/store_test.go internal/liturgy/fetch.go
+git commit -m "liturgy: sigla harvest + offline load"
+```
+
+---
+
+## Task 10: internal/config
+
+**Files:**
+- Create: `internal/config/config.go`, `internal/config/config.toml` (embedded seed), `internal/config/config_test.go`
+
+**Interfaces:**
+- Produces: `config.Config{Versions []string; DefaultVersion string; Width int; All, Offline bool}`; `config.Load() (Config, error)` (env → `~/.config/lectio/config.toml` seed → defaults); `config.Default() Config`.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/config/config_test.go`:
+```go
+package config
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+)
+
+func TestLoadSeeds(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", dir)
+	cfg, err := Load()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if cfg.DefaultVersion != "pl" || cfg.Offline {
+		t.Errorf("defaults wrong: %+v", cfg)
+	}
+	if _, err := os.Stat(filepath.Join(dir, "lectio", "config.toml")); err != nil {
+		t.Error("config not seeded")
+	}
+}
+
+func TestLoadOverride(t *testing.T) {
+	dir := t.TempDir()
+	t.Setenv("XDG_CONFIG_HOME", dir)
+	os.MkdirAll(filepath.Join(dir, "lectio"), 0o755)
+	os.WriteFile(filepath.Join(dir, "lectio", "config.toml"),
+		[]byte("offline = true\ndefault_version = \"wuj\"\n"), 0o644)
+	cfg, _ := Load()
+	if !cfg.Offline || cfg.DefaultVersion != "wuj" {
+		t.Errorf("override not applied: %+v", cfg)
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/config/` — Expected: FAIL.
+
+- [ ] **Step 3: Implement config.go + seed**
+
+`internal/config/config.toml` = the seed from the spec (with `schema_version`, `versions`, `default_version`, `width`, `all`, `offline = false`), `//go:embed`ed. `Default()` returns the same values. `Load`: `LECTIO_CONFIG` env → `os.UserConfigDir()/lectio/config.toml` (seed the embedded default if absent) → parse with `toml.Unmarshal`. Validate each version in `Versions`/`DefaultVersion` against the five codes; error on unknown. Struct tags match the TOML keys.
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/config/` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/config && git commit -m "config: TOML load + seed"
+```
+
+---
+
+## Task 11: internal/render
+
+**Files:**
+- Create: `internal/render/render.go`, `internal/render/render_test.go`
+
+**Interfaces:**
+- Consumes: `liturgy.Section`, `bible.ToEnglishRef`, `bible.Lookup`, version labels/systems.
+- Produces:
+  - `render.GatherVersion(version string, sec liturgy.Section) (label string, blocks []string)` — `pl` returns deduped paragraphs (drop "Słowa Ewangelii" incipit + repeated refrains); a bible version returns verse lines `"C:V  text"` plus a "brak" note for missing groups.
+  - `render.Compare(secs []liturgy.Section, versions []string, width int) string` — the side-by-side column layout (port `render_compare`).
+  - `render.OfflineVersions(versions []string) []string` — drop `pl`, ensure `wuj`.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/render/render_test.go`:
+```go
+package render
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/lukaszkasprzak/lectio/internal/liturgy"
+)
+
+func TestGatherPLDedup(t *testing.T) {
+	sec := liturgy.Section{
+		Heading: "Psalm (Ps 1)",
+		Paragraphs: [][]string{{"stanza one"}, {"refrain"}, {"stanza two"}, {"refrain"}},
+	}
+	_, blocks := GatherVersion("pl", sec)
+	n := 0
+	for _, b := range blocks {
+		if b == "refrain" {
+			n++
+		}
+	}
+	if n != 1 {
+		t.Errorf("refrain appears %d times, want 1 (deduped)", n)
+	}
+}
+
+func TestGatherBible(t *testing.T) {
+	sec := liturgy.Section{Heading: "Ewangelia (J 20, 1. 11-18)"}
+	label, blocks := GatherVersion("wuj", sec)
+	if !strings.Contains(label, "Wujek") {
+		t.Errorf("label = %q", label)
+	}
+	if len(blocks) == 0 || !strings.HasPrefix(blocks[0], "20:1") {
+		t.Errorf("first block = %q", blocks)
+	}
+}
+
+func TestOfflineVersions(t *testing.T) {
+	got := OfflineVersions([]string{"pl", "wuj", "vul"})
+	for _, v := range got {
+		if v == "pl" {
+			t.Error("pl not dropped offline")
+		}
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/render/` — Expected: FAIL.
+
+- [ ] **Step 3: Implement render.go**
+
+Port `gather_version` (pl branch with incipit-drop + dedup; bible branch via `bible.ToEnglishRef(citation, system(version))` then `bible.Lookup`), the version labels/systems maps, `render_compare` (column widths, gap, label+dash header, row assembly), and `OfflineVersions`. `GatherVersion` derives the citation from `sec.Citation` (fallback `ExtractCitation(sec.Heading)`).
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/render/` — Expected: PASS.
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add internal/render && git commit -m "render: gather versions + compare + dedup"
+```
+
+---
+
+## Task 12: internal/cli — subcommand dispatch
+
+**Files:**
+- Replace: `internal/cli/cli.go` (the Task 1 stub); Create: `internal/cli/cli_test.go`
+
+**Interfaces:**
+- Consumes: `config.Load`, `liturgy.Load/Harvest`, `render.*`.
+- Produces: full `Run(args, stdin, stdout, stderr) int` handling `today`, `date D`, `compare LIST`, `show VERSION`, `update`, `--version`, `help`; global `--offline`; per-command `--all --raw --width --refresh --date`.
+
+- [ ] **Step 1: Write the failing test**
+
+`internal/cli/cli_test.go`:
+```go
+package cli
+
+import (
+	"bytes"
+	"strings"
+	"testing"
+)
+
+func TestHelp(t *testing.T) {
+	var out, errb bytes.Buffer
+	code := Run([]string{"help"}, nil, &out, &errb)
+	if code != 0 || !strings.Contains(out.String(), "lectio") {
+		t.Errorf("help code=%d out=%q", code, out.String())
+	}
+}
+
+func TestUnknownCommand(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := Run([]string{"bogus"}, nil, &out, &errb); code != 2 {
+		t.Errorf("unknown cmd code=%d want 2", code)
+	}
+}
+
+func TestVersion(t *testing.T) {
+	var out, errb bytes.Buffer
+	if code := Run([]string{"--version"}, nil, &out, &errb); code != 0 {
+		t.Errorf("version code=%d", code)
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/cli/` — Expected: FAIL.
+
+- [ ] **Step 3: Implement cli.go**
+
+Hand-rolled dispatch (like bread-calc): first non-flag arg is the subcommand (default `today`). Each subcommand builds a `flag.FlagSet`, resolves `config.Load()` (flags override), calls `liturgy.Load`/`Harvest`, renders via `render`, writes to `stdout`. `--offline`/config sets `Options.Offline` and swaps versions via `render.OfflineVersions`. `help`/`-h` prints usage; unknown command → usage error (2); runtime errors → 1. Include a `helpText` const listing every subcommand (mirror the spec's CLI section).
+
+- [ ] **Step 4: Run tests, verify pass**
+
+Run: `go test ./internal/cli/` — Expected: PASS.
+
+- [ ] **Step 5: Build + manual smoke + commit**
+
+```bash
+go build ./cmd/lectio && ./lectio today && ./lectio compare pl,wuj,vul,drb
+git add internal/cli && git commit -m "cli: subcommand dispatch"
+```
+Expected: today's gospel prints; compare shows four columns (network required).
+
+---
+
+## Task 13: internal/tui — styles + model
+
+**Files:**
+- Create: `internal/tui/styles.go`, `internal/tui/tui.go`, `internal/tui/tui_test.go`
+- Replace: `cmd/lectio-ui/main.go`
+
+**Interfaces:**
+- Consumes: `config.Config`, `liturgy.Load`, `render.GatherVersion`, `render.OfflineVersions`.
+- Produces: `tui.New(cfg config.Config) tui.Model` implementing `tea.Model`.
+
+- [ ] **Step 1: Write the failing test (pure model logic)**
+
+`internal/tui/tui_test.go`:
+```go
+package tui
+
+import (
+	"testing"
+
+	"github.com/lukaszkasprzak/lectio/internal/config"
+)
+
+func TestVersionCycle(t *testing.T) {
+	m := New(config.Config{Versions: []string{"pl", "wuj", "vul"}, DefaultVersion: "pl"})
+	if m.version() != "pl" {
+		t.Fatalf("start = %q", m.version())
+	}
+	m = m.cycleVersion(+1)
+	if m.version() != "wuj" {
+		t.Errorf("after tab = %q", m.version())
+	}
+	m = m.cycleVersion(-1)
+	if m.version() != "pl" {
+		t.Errorf("after shift-tab = %q", m.version())
+	}
+}
+
+func TestOfflineDropsPL(t *testing.T) {
+	m := New(config.Config{Versions: []string{"pl", "wuj", "vul"}, DefaultVersion: "pl", Offline: true})
+	for _, v := range m.versions {
+		if v == "pl" {
+			t.Error("offline model kept pl")
+		}
+	}
+}
+```
+
+- [ ] **Step 2: Run test, verify it fails**
+
+Run: `go test ./internal/tui/` — Expected: FAIL.
+
+- [ ] **Step 3: Implement styles.go + tui.go**
+
+`styles.go`: named `lipgloss.Style` per color role (heading bold accent, citation dim, verse number muted, verse text default, refrain italic, header, footer) using `lipgloss.AdaptiveColor`; honor `NO_COLOR`. `tui.go`: `Model{cfg, versions, verIdx, date, sections, scroll, width, loading, err}`; `New` applies `OfflineVersions` when `cfg.Offline` and sets `verIdx` to `default_version`; `version()`, `cycleVersion(d int)`, helpers are pure and unit-tested. `Init` issues the first load `tea.Cmd`; `Update` handles `tea.KeyMsg` (tab/arrows/j/k/g/G/r/q), `readingsMsg`, `errMsg`, `tea.WindowSizeMsg`; `View` renders header + styled reading (via `render.GatherVersion` for the active version, styled per role) + footer keybar. Fetching runs in a `tea.Cmd` returning `readingsMsg`/`errMsg`.
+
+- [ ] **Step 4: Replace cmd/lectio-ui/main.go**
+
+```go
+package main
+
+import (
+	"fmt"
+	"os"
+
+	tea "github.com/charmbracelet/bubbletea"
+
+	"github.com/lukaszkasprzak/lectio/internal/config"
+	"github.com/lukaszkasprzak/lectio/internal/tui"
+)
+
+func main() {
+	cfg, err := config.Load()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+	if _, err := tea.NewProgram(tui.New(cfg), tea.WithAltScreen()).Run(); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(1)
+	}
+}
+```
+
+- [ ] **Step 5: Run tests + build + commit**
+
+```bash
+go test ./internal/tui/ && go build ./cmd/lectio-ui
+git add internal/tui cmd/lectio-ui && git commit -m "tui: colored reader + version switch"
+```
+Expected: tests pass; builds. (Interactive run verified manually: `./lectio-ui`.)
+
+---
+
+## Task 14: README, vet, cross-build, finalize
+
+**Files:**
+- Create: `README.md`
+
+**Interfaces:** none.
+
+- [ ] **Step 1: Write README**
+
+Cover: what it is, install (`make install`), the subcommands, config file + keys, the TUI keys and colors, the `update`/offline workflow, and that it's self-contained (no external tools). Note the Python `daily-reading` is the predecessor.
+
+- [ ] **Step 2: vet + fmt + full test**
+
+Run: `gofmt -w . && go vet ./... && go test ./...`
+Expected: no vet diagnostics; all tests pass.
+
+- [ ] **Step 3: Cross-build sanity**
+
+Run: `make cross && ls dist/`
+Expected: ten binaries.
+
+- [ ] **Step 4: Install + smoke both binaries**
+
+Run: `make install && lectio today && echo '---' && lectio update --days 5`
+Expected: gospel prints; update reports harvested days. (`lectio-ui` verified interactively.)
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add -A && git commit -m "docs: README; finalize build"
+```
+
+---
+
+## Self-Review Notes
+
+- Spec coverage: two binaries (T1,12,13,15-via-14), embedded corpora (T1,4), lookup (T4,5), aliases incl. `J`→John (T3), citation conversion + psalm systems (T2,6), fetch/parse (T7,8), cache HTML+JSON (T8), sigla harvest + offline (T9), config incl. `offline` (T10), render + dedup + pl→wuj (T11), subcommands (T12), colored reader TUI (T13), Makefile/cross/README (T1,14). All spec sections map to a task.
+- Bulk data (73-book aliases, `POLISH_TO_EN`, `DRB_TITLE_FOLD`) is ported verbatim from named source files — concrete, not placeholder.
+- Type consistency: `Verse`, `Section`, `Options`, `Config`, `GatherVersion`, `Lookup`, `ToEnglishRef`, `DrbVerse` names are used identically across tasks.