Require 80% shared title words for same-site related duplicates

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AeJmv3WED4w8S3GV7mMjS7
Drop re-published copies of one story from related lists
2026-10-12 19:26:37 +00:00 · 2026-10-12 18:50:24 +00:00 · 2026-10-12 16:11:43 +00:00 · 2026-10-11 21:34:31 +00:00 · 2026-10-01 20:13:21 +00:00 · 2026-10-01 19:53:06 +00:00
69 changed files with 4329 additions and 435 deletions
@@ -6,11 +6,13 @@ edition = "2024"
 [dependencies]
 ammonia = "4.1.4"
 anyhow = "1.0.104"
+arborium = { version = "2.18.2", default-features = false, features = ["lang-asm", "lang-awk", "lang-bash", "lang-c", "lang-c-sharp", "lang-clojure", "lang-cmake", "lang-commonlisp", "lang-cpp", "lang-css", "lang-d", "lang-dart", "lang-diff", "lang-dockerfile", "lang-elisp", "lang-elixir", "lang-elm", "lang-erlang", "lang-fish", "lang-fsharp", "lang-gleam", "lang-glsl", "lang-go", "lang-graphql", "lang-groovy", "lang-haskell", "lang-hcl", "lang-html", "lang-ini", "lang-java", "lang-javascript", "lang-jq", "lang-json", "lang-julia", "lang-kotlin", "lang-lean", "lang-lua", "lang-make", "lang-matlab", "lang-nix", "lang-objc", "lang-ocaml", "lang-odin", "lang-perl", "lang-php", "lang-powershell", "lang-prolog", "lang-proto", "lang-python", "lang-r", "lang-ruby", "lang-rust", "lang-scala", "lang-scheme", "lang-scss", "lang-solidity", "lang-sql", "lang-starlark", "lang-swift", "lang-toml", "lang-tsx", "lang-typescript", "lang-verilog", "lang-vhdl", "lang-vim", "lang-x86asm", "lang-xml", "lang-yaml", "lang-zig", "lang-zsh"] }
 askama = "0.16.0"
 async-trait = "0.1.92"
 axum = "0.8.9"
 axum-login = { git = "https://github.com/maxcountryman/axum-login.git", rev = "151c72d7a1b4646830f86b4332e6bd6e34d719a7", version = "0.18.0" }
 base64 = "0.23.1"
+betlang = "0.1.1"
 clap = { version = "4.6.6", features = ["derive"] }
 dom_smoothie = "0.18.0"
 epub-builder = "0.8.3"
@@ -8,8 +8,8 @@ the articles, enriches them with HackerNews/Lobsters/Reddit social proof, has
 DeepSeek triage every eligible opening and closely assess a 120-article union,
 then utility-ranks and diversity-caps a 60-item shortlist for Claude Opus 5 — the editor —
 which assembles the issue
-(no minimum size, a hard ceiling), writes a one-line *why* under every headline,
-the summaries and *The Brief*. It assembles two EPUB editions (a standard one
+(no minimum size, a hard ceiling), then writes the summaries and *The Brief*.
+It assembles two EPUB editions (a standard one
 and one tuned for the Xteink X4 e-ink reader), converts the X4 edition to XTC, and
 publishes the lot over its own OPDS catalog — which doubles as a
 [BookOrbit](https://github.com/thallada/bookorbit) watched folder if you run one.
@@ -207,8 +207,8 @@ the database or takes the lock, so it is safe to run next to a live `generate`.
 ## Web site and dashboard

 The server is both the public newspaper index and the private operator UI. An
-anonymous visitor sees titles, authors, sources, metadata, AI summaries, why
-lines and outbound comment links; article bodies, the Brief, the World Briefing
+anonymous visitor sees titles, authors, sources, metadata, AI summaries and
+outbound comment links; article bodies, the Brief, the World Briefing
 and comments stay private. A signed-in `user`
 sees complete issues and article chapters and can download available formats
 from a single download menu. An
@@ -290,7 +290,7 @@ articles do not yet have embeddings to compare.

 | Route | Access | Purpose |
 |---|---|---|
-| `GET /`, `/issues`, `/issues/{date}`, `/feed.xml` | Public | Latest issue, archive, stripped issue index, and equivalent Atom feed. Signed-in issue views expand to the complete issue. |
+| `GET /`, `/issues`, `/issues/{date}`, `/feed.xml`, `/feed.json` | Public | Latest issue, archive, stripped issue index, and the equivalent Atom and JSON Feed 1.1 feeds. Signed-in issue views expand to the complete issue. |
 | `GET /issues/{date}/articles/{id}`, `/world`, `/behind` | User or admin | Private article, World Briefing, and Behind the paper chapters. |
 | `GET /issues/{date}/read` | User or admin | Open the Standard edition in BookOrbit's web reader when the integration is enabled. |
 | `GET /robots.txt`, `/static/{file}` | Public | Crawler policy and embedded CSS, JavaScript, and favicon. |
@@ -721,7 +721,7 @@ toggle and nothing else. The whole matrix:

 | route | `Cache-Control` |
 |---|---|
-| `/`, `/issues`, `/issues/{date}`, `/feed.xml`, `/issues.json` (anonymous) | `public, max-age=300` |
+| `/`, `/issues`, `/issues/{date}`, `/feed.xml`, `/feed.json`, `/issues.json` (anonymous) | `public, max-age=300` |
 | the same pages with a `daily_session=` cookie | `private, no-store` |
 | `/robots.txt` | `public, max-age=86400` |
 | `/static/*?v=<hash>` | `public, max-age=31536000, immutable` |
@@ -855,7 +855,7 @@ epubcheck "./out/The Daily EPUB - $(date +%F).epub"   # expect zero errors

 # 4. Now with the bulk and editor providers, still not publishing
 daily-epub generate --dry-run --out ./out --max-articles 6
-#    → check the lineup is sane (at most 6 picks, each with a "why" line) and the
+#    → check the lineup is sane (at most 6 picks) and the
 #      printed per-provider cost is well under $1

 # 5. Full live run
@@ -157,7 +157,7 @@ affinity_full = 40
 slop_author_penalty = 0.75           # blend and utility × 0.25 for authors with an AI slop verdict
 semantic_min_words = 300
 exploration_slots = 5
-embedding_retention_days = 120       # `features prune`: unrated, unpublished vectors
+embedding_retention_days = 0         # `features prune`: unrated, unpublished vectors; 0 = keep forever
 telemetry_retention_days = 180       # `features prune`: candidate_runs and article_assessments

 [curation.ranking.quotas]
@@ -0,0 +1,79 @@
+# Dashboard tables
+
+How every data table on the dashboard is laid out, and the rules a new table
+must follow so it never grows a horizontal scrollbar on a desktop screen.
+Everything here is plain CSS in `src/web/tailwind.css` plus four cell classes;
+there is no table library and no JavaScript involved.
+
+## The problem this solves
+
+A table used to be `min-width: max-content` inside a `.scroll-x` wrapper, and
+most cells were `white-space: nowrap`. Any table whose natural width exceeded
+the page column (80rem, ~1355px at the site's 110% scale) became a horizontal
+scroller, even on a 2560px monitor, and the columns that mattered were hidden
+behind the scrollbar. Wrapping columns were squeezed to their minimum while the
+nowrap ones kept everything.
+
+## The three rules
+
+1. **Tables get the whole viewport, everything else keeps the page column.**
+   `.dashboard` is a CSS grid with two named column spans: `content` (at most
+   80rem minus the page gutters, exactly what the header uses) and `wide` (the
+   viewport minus the same gutters). Every direct child sits in `content`; a
+   direct-child `.scroll-x` sits in `wide`. The table inside a wide wrapper is
+   `width: auto` (shrink-to-fit) with `min-width` equal to the content column
+   and `max-width: 100%`, centred. A table that fits the page column therefore
+   looks exactly as before; a table that needs more grows, centred, up to the
+   viewport edge; the page itself never scrolls sideways.
+
+2. **Columns wrap before the table scrolls.** The `min-width: max-content` rule
+   is gone. A table shrinks by wrapping its text columns down to their floors,
+   and only when the floors alone no longer fit (phones, mostly) does the
+   `.scroll-x` wrapper scroll. Headers always wrap.
+
+3. **A cell declares what it holds, and nothing else decides its width.**
+   There are exactly four cell classes:
+
+   | class        | use it for                                                     | behaviour                                                              |
+   | ------------ | -------------------------------------------------------------- | ---------------------------------------------------------------------- |
+   | *(none)*     | short prose, names, tokens, badges and badge lists             | wraps at spaces (a `.badge` is nowrap on its own, so lists wrap between badges) |
+   | `num`        | numbers, money, counts                                         | right-aligned tabular figures; `td.num` never wraps, `th.num` may      |
+   | `cell-tight` | timestamps, dates, ids, a single short token that must not split | `white-space: nowrap`. Nothing longer than ~20 characters              |
+   | `cell-wrap`  | titles, URLs, notes, messages, anything free-form              | floor 10rem, ceiling 32rem, `overflow-wrap: anywhere`                  |
+
+   Anything long that must not wrap gets an inner block with a Tailwind clamp
+   (`<div class="line-clamp-2" title="…">`) inside a `cell-wrap` cell; the cell
+   ceiling bounds the column, the clamp bounds the row height. Do not put
+   `truncate`/`line-clamp-*` on a `td` itself (a table cell cannot be a
+   `-webkit-box`), and do not use `table-fixed` on a page-level table (fixed
+   layout needs a definite width and is silently ignored with `width: auto`).
+
+## Checklist for a new table
+
+- Wrap it in `<div class="scroll-x">` and make that wrapper a **direct child** of `<section class="dashboard">` if the
+  table has more than a handful of columns. Tables inside `.card`, `.cards` or
+  `details` stay inside their box and just wrap/scroll there.
+- Let the page scroll. A table that is the page's feature (paginated lists,
+  anything that is the last thing on the page) shows every row at full height;
+  a scrolling island inside a scrolling page just fights the wheel. Add `tall`
+  (70vh cap, own scrollbar) only when the table is a side feature with real
+  content below it, as the profile page's version history is.
+- Give every `td` one of the four classes above according to its content.
+  When in doubt, leave it unclassed: wrapping is the safe default.
+- Never `cell-tight` a name, a title, a reason sentence or a free-text field.
+- Check the page at 390, 1280 and 2560px. At 1440 and above the wrapper's
+  `scrollWidth` must equal its `clientWidth`; at 390 a wide table is allowed to
+  scroll. A table's floor is the sum of its nowrap columns plus 10rem per
+  `cell-wrap` column: the 13-column articles table bottoms out near 1270px, so
+  it still scrolls a little on a 1280px viewport. Tables inside a `.card`
+  cannot grow past the card (20rem minimum), so a card table with more than
+  four numeric columns (run page: provider usage) scrolls inside its card at
+  1280px; move such a table to page level if that matters.
+
+## Measuring
+
+`docs/plans/briefs/dashboard-tables/measure.mjs` logs in as the dev-seed admin,
+visits every dashboard page at several widths and prints, per page, whether the
+document overflows and which table wrappers scroll. Run it against a seeded
+dev server (`cargo run --example seed_dev_db -- ./dev`) before and after a CSS
+change; the "scrolling" count for widths ≥ 1280 should be zero.
@@ -0,0 +1,50 @@
+# Shared brief — dashboard tables (2026-09-20)
+
+The operator sees horizontal scrollbars on most dashboard tables, even on an
+ultrawide monitor, because every table is capped at the 80rem page column and
+`min-width: max-content` forbids wrapping. The fix is a small, reusable table
+framework described in **`docs/dashboard-tables.md` — read it first; it is the
+spec.** Two tasks run in parallel in separate git worktrees:
+
+- `01-css.md` — the CSS side (`src/web/tailwind.css`, rebuilt `app.css`).
+- `02-templates.md` — the template audit (every `td` gets the right cell class).
+
+## Ground rules
+
+- Work only in the worktree named in your brief. **Never touch the main checkout**
+  at `/home/thallada/workspace/the-daily-epub`. **Do not `git commit`** (the sandbox
+  cannot write `.git/worktrees`); leave the work in the tree, the orchestrator
+  commits.
+- Styling lives in **`src/web/tailwind.css`** (Tailwind v4, `@apply` inside
+  `@layer components`, semantic colour tokens). After every CSS change run
+  `npm run css` (writes `src/web/static/app.css`, which the binary embeds with
+  `include_str!`). `npm run css:check` must print no diff at the end.
+- CSP forbids inline `<style>`, `<script>` and `style=""` attributes. No new JS,
+  no new dependencies, no table library: this is plain CSS + four cell classes.
+- Keep every hook `app.js` relies on: `table[data-filter]`, `.table-filter`,
+  `input[data-table-filter]`, `.scroll-x` (the filter script does
+  `table.closest(".scroll-x")`), `form[data-confirm]`, `details[id]`, `[data-refresh]`.
+- Keep `cargo fmt`, `cargo clippy --all-targets -- -D warnings` and the tests
+  green (`cargo test --lib web::` while iterating, one full `cargo test` at the
+  end). **Sandbox note:** inside the Codex sandbox `bind()` on 127.0.0.1 is
+  forbidden; ignore every test that fails with `PermissionDenied`/bind errors
+  (about 17 pre-existing ones). Do not "fix" them.
+- 4 cores / 7 GB shared with another agent building Rust at the same time: one
+  cargo process at a time, be patient.
+- KISS / YAGNI: no config knobs, no per-table width tables, no JS resizing, no
+  responsive card-ification of rows. Where the brief and the code disagree,
+  follow the code and note the deviation in your handoff.
+- Finish by writing `docs/plans/briefs/dashboard-tables/handoff-<task>.md`:
+  what changed (file by file), deviations, what you verified and how, anything
+  left open.
+
+## Previewing (optional — the sandbox usually cannot bind a port)
+
+Seed a throwaway database with `cargo run --example seed_dev_db -- ./dev`
+(git-ignored) and serve it with
+`DAILY_EPUB_SERVER__HMAC_SECRET=$(head -c 48 /dev/urandom | base64) DAILY_EPUB_SERVER__BIND=127.0.0.1:<port> cargo run -- --config ./dev/config.toml serve`.
+`measure.mjs` in this directory (needs `playwright` on the module path; a copy
+lives at `~/.npm/_npx/705bc6b22212b352/node_modules`) prints per page and width
+whether the document overflows and which table wrappers scroll. If you cannot
+bind, rely on the router tests and say so; the orchestrator screenshots every
+page at 390/768/1280/1920/2560 after merging.
@@ -0,0 +1,85 @@
+# Task 01 — table framework CSS
+
+Worktree: `/home/thallada/workspace/the-daily-epub-tables-css` (branch `tables-css`).
+Read `00-shared.md` and `docs/dashboard-tables.md` first. Only `src/web/tailwind.css`
+and the rebuilt `src/web/static/app.css` change in this task (plus your handoff).
+The template audit happens in a sibling worktree; do not edit templates.
+
+## 1. `.dashboard` becomes a content grid
+
+Replace `.dashboard { @apply mx-auto my-8 max-w-7xl px-4 pb-6 … sm:px-6; }` with a
+grid that keeps the page column pixel-identical to the header
+(`mx-auto max-w-7xl px-4 sm:px-6` = content width `80rem - 2 * gutter`, centred):
+
+```css
+.dashboard {
+  --gutter: 1rem;
+  @apply my-8 grid pb-6 font-sans text-base leading-normal;
+  grid-template-columns:
+    [full-start] var(--gutter)
+    [wide-start] 1fr
+    [content-start] minmax(0, calc(80rem - 2 * var(--gutter)))
+    [content-end] 1fr
+    [wide-end] var(--gutter)
+    [full-end];
+}
+@media (width >= 40rem) { .dashboard { --gutter: 1.5rem; } }   /* Tailwind `sm` */
+.dashboard > * { grid-column: content; min-width: 0; }
+.dashboard > .scroll-x { grid-column: wide; }
+```
+
+Keep `.dashboard > * + * { mt-4 }` and every other `.dashboard …` rule as they
+are (margins on grid items work). Verify in the templates that nothing relied
+on the old padding: `.save-bar` uses `-mx-4 sm:-mx-6` to bleed to the edges;
+under the grid it still overflows its `content` area into the gutter columns
+by the same amount, so leave it unless you see a problem. The `sm` breakpoint
+is `40rem` in Tailwind v4 and `@media` rem is always 16px-based, so the query
+above matches `sm:` exactly.
+
+Prototype measured in Chromium and Firefox at 390/1280/2560: `h1` left edge and
+width identical to today, no document overflow, table centred and wider than
+the column only when its content needs it.
+
+## 2. Tables shrink by wrapping; page-level tables may grow past the column
+
+- Delete `.scroll-x > table { min-width:max-content; }`.
+- Add, for the wide wrapper only:
+
+```css
+.dashboard > .scroll-x > table {
+  width: auto;                                   /* shrink-to-fit */
+  min-width: min(100%, calc(80rem - 2 * var(--gutter)));
+  max-width: 100%;
+  margin-inline: auto;
+}
+```
+
+  A table narrower than the page column fills the column as today; a wider one
+  grows, centred, to the viewport edge; the wrapper scrolls only past that.
+  Tables that are not direct children (cards, disclosures, signal tables inside
+  cells) keep `w-full` from the base rule and simply wrap, then scroll.
+
+## 3. Cell vocabulary (exactly four classes, see the doc's table)
+
+- `.num` → `@apply text-right tabular-nums;` and `td.num { @apply whitespace-nowrap; }`.
+  Header cells with `.num` may wrap ("cache write", "matched articles").
+- `.cell-tight` unchanged (`whitespace-nowrap`).
+- `.cell-wrap` → `@apply min-w-[10rem] max-w-[32rem] whitespace-normal; overflow-wrap:anywhere;`
+  (ceiling raised from 24rem so titles get a single line when the screen has
+  room; `max-width` on a cell is honoured by Chromium and Firefox for the
+  column's max-content contribution — measured).
+- `th` keeps wrapping (no nowrap); keep the sticky `thead`.
+- `td > pre.preview { max-w-md }` and `.rating-cell` rules stay.
+
+## 4. Small things to keep honest
+
+- `.prose-body table` (reader pages) keeps its own rules; do not touch.
+- Put a short comment above the table rules pointing at `docs/dashboard-tables.md`.
+- `npm run css`, then `cargo build` (the binary embeds app.css) and
+  `cargo test --lib web::`. Router tests assert on markup, not on these rules,
+  so nothing should break; if something does, say what and why in the handoff.
+- If you can run the dev server + `measure.mjs`, do it and paste the ≥1280 lines
+  for `/dashboard/articles`, `/dashboard/runs` and `/dashboard/runs/1` into the
+  handoff. With unchanged templates some tables will still scroll at 1280 —
+  that is expected until the template audit lands — but at 2560 the articles
+  and candidates tables must fit without scrolling.
@@ -0,0 +1,65 @@
+# Task 02 — template audit: every cell says what it holds
+
+Worktree: `/home/thallada/workspace/the-daily-epub-tables-tpl` (branch `tables-tpl`).
+Read `00-shared.md` and `docs/dashboard-tables.md` first. Only files under
+`src/web/templates/` change in this task (plus your handoff). The CSS lands in a
+sibling worktree; assume the four cell classes behave exactly as the doc's
+table says (`cell-wrap` floor 10rem / ceiling 32rem with `overflow-wrap:anywhere`,
+`cell-tight` nowrap, `td.num` nowrap right-aligned, unclassed cells wrap at
+spaces, `th` always wraps, page-level tables grow past the page column when
+their content needs it).
+
+Go through every `<table>` in `src/web/templates/dashboard/*.html`,
+`src/web/templates/_candidate_row.html` and `src/web/templates/_signals_table.html`
+and apply these rules to each `td`:
+
+1. **`cell-tight` only on timestamps, dates, ids and single tokens ≤ ~20
+   characters** (`first_seen`, `when`, `started`, `finished`, `requested`,
+   `created`, `last_login`, `saved_at`, `changed_at`, `event_at`, `issue_date`,
+   `published`, `run.date`, `run.funnel` "310 → 200 → …", `age → decay`,
+   `#id`). **Remove it** from feed names/titles (`article.feed`, `candidate.feed`,
+   `miss.feed`, `row.feed_credits`, nearest-article `feed`), reasons
+   (`article.reason`, `row.reason`, `candidate.reason`), "admitted by" cells,
+   usernames / `requested_by` / `saved_by`, roles, sources, kinds, job names,
+   and from any cell that combines a badge with more text (stage + run date).
+   A `.badge` is already `whitespace-nowrap` on its own, so a badge-only cell
+   needs no class.
+2. **`cell-wrap` on every free-form column**: titles, URLs, notes, messages,
+   "reason or comment", facet values, badge lists (interests), config diff
+   before/after, anything a user typed. Keep it where it already is.
+3. **`num` on numbers only** (it already is; just make sure no text column
+   uses it because it wanted right alignment — `#id` cells may keep `num`).
+4. **Long text that should not stretch a row**: if a column can hold hundreds of
+   characters (job `message`, rating-import `message`, `note`), keep
+   `cell-wrap` and wrap the text in `<div class="line-clamp-3" title="{{ … }}">`
+   **only** if the full text is reachable somewhere else on the page or via the
+   `title`; otherwise let it wrap. Never put `truncate`/`line-clamp-*` on a `td`.
+5. **`dashboard/feeds.html`**: drop `table-fixed` (fixed layout is ignored once
+   the page-level table is `width:auto`). Keep the `w-*` hints on the `th`s
+   (they act as minimums under auto layout), keep the `line-clamp-*`/`truncate`
+   inner elements — they already sit on block children, which is the pattern —
+   and put `cell-wrap` on the Feed and Why cells if it is not there. The
+   actions cell keeps its forms; give it `cell-tight` only if the buttons wrap
+   badly, otherwise leave it unclassed.
+6. **`dashboard/run.html` Feeds card** (`<table class="table-fixed">` inside
+   `.card`): this table is `w-full` inside a card, so `table-fixed` still works
+   there; leave it, but it is the only allowed `table-fixed`.
+7. **Header cells**: remove nothing, but make sure no `th` has `whitespace-nowrap`
+   or `cell-tight`; long headers such as
+   "considered → eligible → triaged → assessed → shortlisted → selected" may wrap.
+8. **Wrappers**: every page-level table (more than a handful of columns:
+   runs, candidates, articles, ratings current/events, interests, feeds, users,
+   jobs, stats runs/costs, settings history, profile versions, near misses,
+   funnel) must sit in a `<div class="scroll-x …">` that is a **direct child**
+   of `<section class="dashboard …">` — check that no such wrapper is nested in
+   a stray `<div>`; tables inside `.card`/`.cards`/`details` stay where they are.
+   Keep `tall` where it is today.
+
+Do not change the columns themselves, their order, the text, or any
+`data-*`/`id`/`name`/`action`/`aria-*` attribute. Do not touch reader/public
+templates (`issue_*.html`, `article.html`, `world.html`, `behind.html`, `_toc.html`).
+
+Verify: `cargo test --lib web::` (router tests assert on text and some class
+names; if one breaks only because a class moved, update the test and say so),
+then `cargo fmt`/`clippy`. List in the handoff, per template, which cells lost
+`cell-tight`, which gained `cell-wrap`, and any clamp you added.
@@ -0,0 +1,75 @@
+# Dashboard tables CSS handoff
+
+## What changed
+
+- `src/web/tailwind.css`
+  - Disabled Tailwind v4 automatic repository scanning with
+    `@import "tailwindcss" source(none);`; retained the explicit template and
+    `app.js` sources.
+  - Replaced the padded/max-width dashboard container with the specified named
+    `content`/`wide` grid and 1rem/1.5rem gutter variable.
+  - Let direct-child `.scroll-x` wrappers occupy the wide track and made their
+    tables shrink-to-fit between the content-column floor and wrapper ceiling.
+  - Removed the global `.scroll-x > table { min-width:max-content; }` rule.
+  - Kept `.num` alignment/tabular figures on headers and cells, while limiting
+    nowrap to `td.num`.
+  - Raised `.cell-wrap`'s maximum width from 24rem to 32rem.
+  - Added a pointer from the table rules to `docs/dashboard-tables.md`.
+- `src/web/static/app.css`
+  - Rebuilt from the Tailwind source and checked for reproducibility.
+
+No templates, JavaScript, reader table rules, preview rules, or rating-cell
+rules changed.
+
+## Generated CSS diff audit
+
+Compared committed and rebuilt CSS one closing brace per line with:
+
+```sh
+diff -U0 \
+  <(git show HEAD:src/web/static/app.css | tr '}' '\n') \
+  <(tr '}' '\n' < src/web/static/app.css)
+```
+
+The 177-line diff contained 111 removed and 12 added content lines (excluding
+the two diff file headers). The component-rule changes were exactly the table
+framework changes above: remove `.scroll-x > table`, replace `.dashboard`, add
+the three direct-child dashboard selectors, split `td.num` nowrap from `.num`,
+and change `.cell-wrap` from 24rem to 32rem. The remainder was removal of
+utilities, unused theme symbols, and supporting custom properties that had
+previously been emitted by repository-wide automatic source discovery. There
+were no unrelated added selectors.
+
+The rebuilt file shrank from 77,721 to 70,697 bytes. The documentation-only
+utility selectors `.line-clamp-3`, `.max-w-[32rem]`, `.min-w-[10rem]`, and
+`.pb-6` are absent. The semantic `.cell-wrap` component still contains
+`min-width:10rem` and `max-width:32rem`, and `.dashboard` still contains its
+requested `padding-bottom` declaration.
+
+## Verification
+
+- `npm run css` — passed.
+- `npm run css:check` — passed with no diff.
+- `cargo build` — passed after the final CSS build.
+- `cargo test --lib web::` — 135 passed; the two failures were
+  `web::dashboard::feeds::tests::a_duplicate_subscription_still_decides_the_row`
+  and `web::dashboard::feeds::tests::add_subscribes_and_records_the_miniflux_feed_id`.
+  Both failed at the test bind setup with the documented
+  `PermissionDenied` / `Operation not permitted` sandbox error.
+- `cargo fmt` — passed without changes.
+- `cargo clippy --all-targets -- -D warnings` — passed.
+- `git diff --check` — passed.
+
+An extra full `cargo test` required by the shared brief was attempted, but the
+filesystem ran out of space while creating another test archive before tests
+started. I removed only this package's generated artifacts with
+`cargo clean -p daily-epub` (2.0 GiB), then reran the complete user-requested
+command sequence above successfully. The full suite remains unverified; the
+focused web suite is verified subject only to the two allowed bind failures.
+
+## Deviations and open items
+
+There are no implementation deviations. I did not run the browser measurement
+script because the sandbox cannot bind a preview server, as independently
+confirmed by the focused test failures. Visual viewport measurement remains for
+the post-merge environment described in the shared brief.
@@ -0,0 +1,46 @@
+# Dashboard tables template handoff
+
+Implemented `02-templates.md` against `00-shared.md` and
+`docs/dashboard-tables.md`. No columns, content, hooks, or attributes were
+changed. The existing page-level `.scroll-x` wrappers already had the required
+direct-child topology, so none moved.
+
+## Cell audit by template
+
+| Template | Cells that lost `cell-tight` | Cells that gained `cell-wrap` | Clamp added |
+| --- | --- | --- | --- |
+| `_candidate_row.html` | Feed, stage, reason, admitted by, flags | Flags (badge list) | None |
+| `_signals_table.html` | None | None | None |
+| `dashboard/article.html` | Run history: stage, reason, admitted by; nearest articles: feed, rating; rating events: label, kind, source, user | Top-interests interest name | Rating-event note: inner `line-clamp-3` with the full note in `title` |
+| `dashboard/articles.html` | Feed, last stage (badge plus run date), reason, rating | None | None |
+| `dashboard/feeds.html` | None | None (Feed and Why already had it) | None (existing Feed/Why inner clamps retained) |
+| `dashboard/interests.html` | Category | None | None |
+| `dashboard/jobs.html` | Job name, requested by, status | None (message already had it) | Message: inner `line-clamp-3` with the full message in `title` |
+| `dashboard/profile.html` | Saved by, restore action | Preview | None |
+| `dashboard/ratings.html` | Imports: verdict, status; events: verdict, source, by; current: when/by, feed credit, used last run | Current feed credit | Import message, event note, and current note: inner `line-clamp-3` with full text in `title` |
+| `dashboard/run.html` | Funnel stage; near misses: feed, stage | None | None |
+| `dashboard/runs.html` | Status (badge plus dry-run text) | None | None |
+| `dashboard/settings_history.html` | Who | None | None |
+| `dashboard/stats.html` | Runs status | None | None |
+| `dashboard/users.html` | None | None | None |
+
+`dashboard/feeds.html` also lost page-level `table-fixed`; its existing header
+width hints and inner Feed/Why clamps remain. The card-local `table-fixed` feeds
+table in `dashboard/run.html` remains as specified.
+
+## Deviations
+
+None. Templates whose cells were already compliant were left unchanged.
+
+## Verification
+
+- `cargo test --lib web::`: 135 passed; two Miniflux mock-server tests failed
+  only because sandbox `bind()` returned `PermissionDenied` at
+  `src/web/dashboard/feeds.rs:497`, as permitted by the brief.
+- `cargo fmt`: passed.
+- `cargo clippy --all-targets -- -D warnings`: passed.
+- `git diff --check`: passed.
+
+The first clippy attempt exhausted the filesystem while writing generated Rust
+metadata. Removing the disposable `target/debug/incremental` cache freed enough
+space; the exact clippy command then completed successfully.
@@ -0,0 +1,42 @@
+// usage: node measure.mjs <port> <outdir> [widths]
+import { chromium } from "playwright";
+import fs from "node:fs";
+const [port, outdir, widthsArg] = process.argv.slice(2);
+const base = `http://127.0.0.1:${port}`;
+const widths = (widthsArg || "390,768,1280,1920,2560").split(",").map(Number);
+const pages = ["/dashboard","/dashboard/runs","/dashboard/runs/1","/dashboard/runs/2","/dashboard/articles","/dashboard/articles/1","/dashboard/ratings","/dashboard/ratings?tab=events","/dashboard/interests","/dashboard/feeds","/dashboard/feeds?status=added","/dashboard/profile","/dashboard/stats","/dashboard/jobs","/dashboard/settings","/dashboard/settings/history","/dashboard/users","/","/issues","/account"];
+fs.mkdirSync(outdir, { recursive: true });
+const browser = await chromium.launch();
+const ctx = await browser.newContext({ viewport: { width: 1280, height: 900 } });
+const page = await ctx.newPage();
+await page.goto(`${base}/login`);
+await page.fill('input[name="username"]', "admin");
+await page.fill('input[name="password"]', "adminpassword123");
+await page.click('button[type="submit"]');
+await page.waitForLoadState("networkidle");
+const report = [];
+for (const w of widths) {
+  await page.setViewportSize({ width: w, height: 1000 });
+  for (const p of pages) {
+    const resp = await page.goto(`${base}${p}`, { waitUntil: "networkidle" });
+    const status = resp?.status();
+    const info = await page.evaluate(() => {
+      const de = document.documentElement;
+      const container = document.querySelector(".dashboard, main > section, main > div, main");
+      const tables = [...document.querySelectorAll("table")].map((t) => {
+        const host = t.closest(".scroll-x") || t.parentElement;
+        const r = t.getBoundingClientRect();
+        return { cls: t.className, ths: t.querySelectorAll("thead th").length, rows: t.querySelectorAll("tbody tr").length, tableW: Math.round(r.width), hostW: Math.round(host.getBoundingClientRect().width), hostScroll: host.scrollWidth, hostClient: host.clientWidth, overflow: host.scrollWidth > host.clientWidth + 1 };
+      });
+      const culprits = [...document.querySelectorAll("body *")].filter((el) => el.scrollWidth > el.clientWidth + 1 && getComputedStyle(el).overflowX === "visible" && !el.closest("table")).slice(0, 5).map((el) => `${el.tagName.toLowerCase()}.${String(el.className).split(" ").slice(0,2).join(".")} ${el.scrollWidth}>${el.clientWidth}`);
+      return { pageOverflow: de.scrollWidth > de.clientWidth, docW: de.clientWidth, containerW: container ? Math.round(container.getBoundingClientRect().width) : null, tables, culprits };
+    });
+    const name = p.replace(/[\/?=]/g, "_").replace(/^_/, "") || "root";
+    if (w === 1280 || w === 2560 || w === 390) await page.screenshot({ path: `${outdir}/${w}-${name}.png`, fullPage: true });
+    report.push({ w, p, status, ...info });
+    const bad = info.tables.filter((t) => t.overflow);
+    console.log(`${w} ${p} status=${status} page=${info.pageOverflow ? "OVERFLOW" : "ok"} container=${info.containerW} tables=${info.tables.length} scrolling=${bad.length}${bad.length ? " [" + bad.map((t) => `${t.cls || "-"}:${t.hostScroll}>${t.hostClient}`).join(", ") + "]" : ""}${info.culprits.length ? " culprits=" + info.culprits.join(" | ") : ""}`);
+  }
+}
+fs.writeFileSync(`${outdir}/report.json`, JSON.stringify(report, null, 1));
+await browser.close();
@@ -212,7 +212,7 @@ de generate --dry-run --out /var/lib/daily-epub/out-check
 The dry run makes real DeepSeek, Claude and Voyage calls but publishes nothing and writes no
 `issues` row. Read the printed lineup and the four report lines (`curation:`, `admission:`,
 `preference:`, `providers:`); the cost should be well under $1. Then read the EPUB it wrote
-(Calibre or KOReader): The Brief, the `Why it's here` line under each headline, and the new
+(Calibre or KOReader): The Brief and the new
 Behind-the-paper chapter before the colophon. Finally:

 ```sh
@@ -261,7 +261,7 @@ content filter (those are bisected, retried once on the editor provider, and the
 `provider_rejected` so they are not retried daily). The `triage:` and `assess:` log lines say how
 many were reused versus requested. The bulk-side cost of the second run is therefore small; the
 editor, summaries and the Brief are the real spend. Compare the two
-lineups, the `why` lines and the Brief side by side, and the `providers:` cost line. To switch
+lineups and the Brief side by side, and the `providers:` cost line. To switch
 for good, set `editor = "gemini"` in `[llm]` (and `summary_model` stays `editor`, so summaries
 move with it). The same trick works for the bulk role: `DAILY_EPUB_LLM__BULK=gemini`.

@@ -370,7 +370,6 @@ fn pick_for(target: &Target, content_html: String) -> Pick {
        section: target.issue.clone(),
        position: 0,
        is_lead: false,
-        why: None,
        summary: None,
        llm: None,
        top_interests: Vec::new(),
@@ -29,14 +29,13 @@ use jiff::civil::Date;
 const ADMIN_PASSWORD: &str = "adminpassword123";
 const READER_PASSWORD: &str = "readerpassword123";

-/// (section, title, feed, summary, why, words)
-const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
+/// (section, title, feed, summary, words)
+const STORIES: &[(&str, &str, &str, &str, i64)] = &[
    (
        "Top Stories",
        "How a Forty-Year-Old Filesystem Quietly Rewrote Its Write Path",
        "Systems Weekly",
        "A long, careful account of the redesign, with the benchmarks that justified it and the two regressions that nearly sank it.",
-        "The systems story with enough operational detail to matter to you",
        3100,
    ),
    (
@@ -44,7 +43,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "The Case Against Feature Flags",
        "Alice on Software",
        "Argues that flags outlive their purpose and proposes a retirement discipline, with examples from three codebases.",
-        "A contrarian take on tooling you use every day",
        1850,
    ),
    (
@@ -52,7 +50,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "What the Latest Battery Chemistry Actually Changes",
        "Ars Technica",
        "Separates the press-release claims from the measurable improvements in energy density and cycle life.",
-        "You keep an eye on energy storage; this one is unusually sober",
        2200,
    ),
    (
@@ -60,7 +57,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "A Field Guide to Distributed Consensus, Told Through One Outage",
        "The Morning Paper",
        "Walks through a real incident to explain leader election, log replication and why the fix was a config change.",
-        "Distributed systems explained with an actual outage rather than diagrams",
        4200,
    ),
    (
@@ -68,7 +64,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "Why Every Map Is a Lie & How Cartographers Choose Which One to Tell",
        "Longreads",
        "A history of projections and the politics behind them, from Mercator to the maps in your phone.",
-        "Long-form nonfiction outside the technical orbit you asked for",
        5100,
    ),
    (
@@ -76,7 +71,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "Notes on Writing a Rust Linter That People Actually Enable",
        "Rust Blog",
        "Design notes on false-positive budgets, fix suggestions and the social side of shipping a lint.",
-        "Rust tooling with a practical bent",
        1600,
    ),
    (
@@ -84,7 +78,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "The Terminal Is the Best UI We Have and It Is Getting Better",
        "Julia's Notebook",
        "A tour of modern terminal features (hyperlinks, images, synchronized output) and which tools use them.",
-        "Terminal ergonomics, one of your recurring interests",
        1300,
    ),
    (
@@ -92,7 +85,6 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "A Small-Town Bakery's Sourdough Starter Turns One Hundred",
        "Saveur",
        "A charming profile of a starter kept alive across four generations and the bread it still makes.",
-        "A small-scene delight outside the usual technical orbit",
        900,
    ),
    (
@@ -100,15 +92,14 @@ const STORIES: &[(&str, &str, &str, &str, &str, i64)] = &[
        "Inside the Community Keeping 1990s Synthesizers Alive",
        "Sound on Sound",
        "Repair collectives, replacement parts and the odd economics of vintage gear.",
-        "Music hardware, for the weekend",
        1700,
    ),
 ];

-fn story_article(index: usize, story: &(&str, &str, &str, &str, &str, i64)) -> Article {
+fn story_article(index: usize, story: &(&str, &str, &str, &str, i64)) -> Article {
    let id = index as i64 + 1;
    let entry_id = 1000 + id;
-    let (_, title, feed, _, _, words) = *story;
+    let (_, title, feed, _, words) = *story;
    let mut article = fixtures::article(id, entry_id, title);
    article.feed_title = feed.to_string();
    article.feed_id = 7 + index as i64;
@@ -140,9 +131,25 @@ fn body_html(title: &str, words: i64) -> String {
            html.push_str("<blockquote><p>A pull quote that the author would rather you remembered than the rest.</p></blockquote>");
        }
        if index == 7 {
-            html.push_str(
-                "<pre><code>fn main() {\n    println!(\"hello, reader\");\n}</code></pre>",
-            );
+            // One block the source marked as Rust, one it left for detection.
+            html.push_str(concat!(
+                "<pre data-lang=\"rust\"><code>/// Greets whoever is reading.\n",
+                "fn main() {\n",
+                "    let reader: &amp;str = \"reader\";\n",
+                "    for n in 0..3 {\n",
+                "        println!(\"hello, {reader} #{n}\"); // three times\n",
+                "    }\n",
+                "}</code></pre>",
+                "<pre><code>import json\n\n",
+                "def load(path: str) -&gt; dict:\n",
+                "    \"\"\"Read a JSON config, or an empty one.\"\"\"\n",
+                "    try:\n",
+                "        with open(path) as f:\n",
+                "            return json.load(f)\n",
+                "    except FileNotFoundError:\n",
+                "        return {}  # first run\n",
+                "</code></pre>",
+            ));
        }
        html.push_str("<p>Paragraph ");
        html.push_str(&(index + 1).to_string());
@@ -167,7 +174,7 @@ fn dev_issue(date: Date, issue_number: i64, generated_at: Timestamp) -> Issue {
    let mut picks = Vec::new();
    let mut summaries = BTreeMap::new();
    for (index, story) in STORIES.iter().enumerate() {
-        let (section, _, _, summary, why, _) = *story;
+        let (section, _, _, summary, _) = *story;
        if !section_order.iter().any(|s| s == section) {
            section_order.push(section.to_string());
        }
@@ -237,7 +244,6 @@ fn dev_issue(date: Date, issue_number: i64, generated_at: Timestamp) -> Issue {
            section: section.to_string(),
            position,
            is_lead: index == 0,
-            why: Some(why.to_string()),
            summary: Some(summary.to_string()),
            llm,
            top_interests,
@@ -418,7 +424,6 @@ async fn seed_near_misses(db: &Db, run_id: i64) -> anyhow::Result<()> {
                rank_utility: Some(index + 10),
                cluster_id: Some(index),
                cluster_rank: Some(1),
-                editor_why: None,
            },
        )
        .await?;
@@ -0,0 +1,131 @@
+//! Preview an article the way the Xteink X4 will show it.
+//!
+//! Browsers are a poor stand-in for the X4: its pages are rendered ahead of
+//! time by the XTC converter's CREngine, which has its own defaults (`code` is a
+//! block, `pre` has no margin) and only four grey levels. This builds both
+//! EPUB editions around one article, runs the real converter on the X4 one and
+//! decodes every page to `page-NNN.png`.
+//!
+//! ```text
+//! cargo run --example x4_preview -- <article URL | HTML file> <out dir>
+//! cargo run --example x4_preview -- --convert <x4.epub> <out dir>
+//! ```
+//!
+//! A URL goes through the real extraction path; an HTML file is used as the
+//! stored body as-is. `--convert` skips the build, for iterating on a
+//! stylesheet inside an unzipped EPUB. Needs the converter at
+//! `/opt/epub-to-xtc-converter` and runs it with `xtc-settings.example.json`.
+
+use std::path::{Path, PathBuf};
+use std::process::{Command, Stdio};
+
+use daily_epub::config::Config;
+use daily_epub::epub;
+use daily_epub::extract::Extractor;
+use daily_epub::types::Edition;
+
+const CONVERTER: &str = "/opt/epub-to-xtc-converter/cli/index.js";
+const SETTINGS: &str = "xtc-settings.example.json";
+
+#[tokio::main]
+async fn main() -> anyhow::Result<()> {
+    let args: Vec<String> = std::env::args().skip(1).collect();
+    match args.as_slice() {
+        [flag, epub, out] if flag == "--convert" => {
+            let pages = convert(Path::new(epub), Path::new(out))?;
+            println!("{pages} pages in {out}");
+        }
+        [source, out] => {
+            let out = PathBuf::from(out);
+            std::fs::create_dir_all(&out)?;
+            let html = if source.starts_with("http") {
+                let extractor = Extractor::new(reqwest::Client::new(), vec![]);
+                let page = extractor.fetch_readable(source).await?;
+                extractor.finish_readable(source, &page).content_html
+            } else {
+                std::fs::read_to_string(source)?
+            };
+            std::fs::write(out.join("stored.html"), &html)?;
+
+            let mut issue = epub::fixtures::issue();
+            issue.lineup.picks.truncate(1);
+            issue.lineup.picks[0].article.content_html = html;
+            let config = Config::default();
+            for edition in [Edition::Standard, Edition::X4] {
+                let artifact =
+                    epub::build_edition_with_images(&issue, edition, &config, &out, &[])?;
+                println!("{edition:?}: {}", artifact.path.display());
+                if edition == Edition::X4 {
+                    let pages = convert(&artifact.path, &out)?;
+                    println!("{pages} X4 pages in {}", out.display());
+                }
+            }
+        }
+        _ => anyhow::bail!(
+            "usage: x4_preview <URL | HTML file> <out dir> | --convert <epub> <out dir>"
+        ),
+    }
+    Ok(())
+}
+
+/// Run the converter on `epub` and decode its pages into `out`.
+fn convert(epub: &Path, out: &Path) -> anyhow::Result<usize> {
+    std::fs::create_dir_all(out)?;
+    let xtch = out.join("x4.xtch");
+    let status = Command::new("node")
+        .args([CONVERTER, "convert"])
+        .arg(epub)
+        .arg("-o")
+        .arg(&xtch)
+        .args(["-f", "xtch", "-c", SETTINGS])
+        .stdout(Stdio::null())
+        .status()?;
+    anyhow::ensure!(status.success(), "converter failed: {status}");
+    decode_xtch(&xtch, out)
+}
+
+fn u16_at(bytes: &[u8], at: usize) -> usize {
+    u16::from_le_bytes([bytes[at], bytes[at + 1]]) as usize
+}
+
+fn u64_at(bytes: &[u8], at: usize) -> usize {
+    u64::from_le_bytes(bytes[at..at + 8].try_into().unwrap()) as usize
+}
+
+/// Decode every page of an XTCH container to a PNG.
+///
+/// Layout per the converter's `docs/xtc-format-spec.md`: the page index is at
+/// the offset in header bytes 0x18..0x20, 16 bytes per page (offset, size,
+/// width, height). Each page is a 22-byte header and two bit planes stored
+/// column by column, right to left, 8 vertical pixels per byte. The plane
+/// order follows the encoder (`cli/encoder.js`), not the spec's table: the
+/// first plane holds the level's low bit, and 0b01 is dark grey.
+fn decode_xtch(path: &Path, out: &Path) -> anyhow::Result<usize> {
+    let bytes = std::fs::read(path)?;
+    let pages = u16_at(&bytes, 0x06);
+    let index = u64_at(&bytes, 0x18);
+    for page in 0..pages {
+        let entry = index + page * 16;
+        let (offset, width, height) = (
+            u64_at(&bytes, entry),
+            u16_at(&bytes, entry + 12),
+            u16_at(&bytes, entry + 14),
+        );
+        let plane = (width * height).div_ceil(8);
+        let column = height.div_ceil(8);
+        let data = &bytes[offset + 22..];
+        let mut image = image::GrayImage::new(width as u32, height as u32);
+        for x in 0..width {
+            for y in 0..height {
+                let byte = (width - 1 - x) * column + y / 8;
+                let bit = 7 - (y % 8);
+                let low = (data[byte] >> bit) & 1;
+                let high = (data[plane + byte] >> bit) & 1;
+                let shade = [255, 85, 170, 0][usize::from(high << 1 | low)];
+                image.put_pixel(x as u32, y as u32, image::Luma([shade]));
+            }
+        }
+        image.save(out.join(format!("page-{page:03}.png")))?;
+    }
+    Ok(pages)
+}
@@ -0,0 +1,12 @@
+-- Related articles under each web issue article: the nearest embedded articles
+-- across the whole archive, computed when the issue is published (and by
+-- `features related` for older issues). Stored rather than computed per page
+-- view because finding them is a scan of every cached embedding.
+CREATE TABLE issue_related (
+    issue_date TEXT NOT NULL REFERENCES issues(date) ON DELETE CASCADE,
+    article_id INTEGER NOT NULL REFERENCES articles(id) ON DELETE CASCADE,
+    position   INTEGER NOT NULL,              -- 0 = closest
+    related_id INTEGER NOT NULL REFERENCES articles(id) ON DELETE CASCADE,
+    cosine     REAL NOT NULL,
+    PRIMARY KEY (issue_date, article_id, position)
+);
@@ -490,6 +490,8 @@ pub struct RankingConfig {
    pub slop_author_penalty: f64,
    pub semantic_min_words: i64,
    pub exploration_slots: usize,
+    /// Days before `features prune` drops unrated, unpublished vectors; 0 keeps
+    /// them forever (the default, so related articles span the whole archive).
    pub embedding_retention_days: i64,
    pub telemetry_retention_days: i64,
    pub quotas: RankingQuotas,
@@ -517,7 +519,7 @@ impl Default for RankingConfig {
            slop_author_penalty: 0.75,
            semantic_min_words: 300,
            exploration_slots: 5,
-            embedding_retention_days: 120,
+            embedding_retention_days: 0,
            telemetry_retention_days: 180,
            quotas: RankingQuotas::default(),
            weights: RankingWeights::default(),
@@ -2104,7 +2106,7 @@ mod tests {
        assert_eq!(ranking.weights.utility.knn, 0.10);
        assert_eq!(ranking.weights.utility.affinity, 0.05);
        assert_eq!(ranking.diversity.per_cluster_cap, 2);
-        assert_eq!(ranking.embedding_retention_days, 120);
+        assert_eq!(ranking.embedding_retention_days, 0);
        assert_eq!(ranking.telemetry_retention_days, 180);
        cfg.validate().unwrap();

@@ -19,8 +19,6 @@ pub struct SelectionItem {
    pub position: i64,
    #[serde(default)]
    pub lead_story: bool,
-    #[serde(default)]
-    pub why: Option<String>,
 }

 pub const EDITOR_INSTRUCTIONS: &str = r#"TASK: assemble today's issue of The Daily EPUB from the shortlist below.
@@ -39,16 +37,6 @@ RULES
 6. Never select two articles that tell the same story.
 7. SIZE: aim for about {soft_target}; never more than {hard_max}; there is NO minimum.
   If only nine pieces deserve the reader's morning, publish nine. Never pad.
-8. For every pick write "why": at most 14 words. It is printed under the headline
-   as "Why it's here", above the summary, with the matched interests listed right
-   beneath it. So it must NOT describe the piece (the summary does that) and must
-   NOT just list interests (already shown). Say why THIS reader gets THIS piece
-   today: the itch it scratches, the rated piece it rhymes with, the argument he
-   will want to pick, the gap in today's paper it fills, or the exploration bet it
-   is. Second person is fine.
-   Bad:  "A candid Rust query engine post-mortem showing why io_uring lost to mmap."
-   Good: "The io_uring-versus-mmap verdict you'd want before touching your own engine."
-
 EDITORIAL JUDGEMENT
 - Depth over coverage. Drop anything you would not defend to him in person.
 - Diversity is a feature: do not let one subject, one format, or one feed dominate,
@@ -62,7 +50,7 @@ EDITORIAL JUDGEMENT
 - Scores are evidence, not instructions. Overrule them when the paper reads better.

 Return JSON exactly:
-{"picks": [{"id": 123, "section": "Top Stories", "position": 1, "lead_story": true, "why": "…"}]}"#;
+{"picks": [{"id": 123, "section": "Top Stories", "position": 1, "lead_story": true}]}"#;

 pub fn build_prompt(
    shortlist: &[Candidate],
@@ -398,16 +386,6 @@ pub fn parse_selection_response(raw: &str) -> Vec<SelectionItem> {
                        })
                    })
                    .unwrap_or(false),
-                why: object
-                    .get("why")
-                    .and_then(serde_json::Value::as_str)
-                    .map(|why| {
-                        why.split_whitespace()
-                            .take(14)
-                            .collect::<Vec<_>>()
-                            .join(" ")
-                    })
-                    .filter(|why| !why.is_empty()),
            })
        })
        .collect()
@@ -483,7 +461,6 @@ pub async fn select(
                    section: "From the Blogroll".into(),
                    position: i64::MAX,
                    lead_story: false,
-                    why: Some("A standing source you always want represented".into()),
                },
                candidate.clone(),
            ));
@@ -592,7 +569,6 @@ fn assemble(
                section: item.section,
                position: *position,
                is_lead: Some(item.id) == lead_id,
-                why: item.why,
                summary: None,
                llm: candidate.assessment.deep,
                top_interests: candidate
@@ -639,7 +615,6 @@ pub fn select_without_llm(
                section: heuristic_section(&candidate, sections),
                position: chosen.len() as i64 + 1,
                lead_story: false,
-                why: None,
            },
            candidate,
        ));
@@ -742,7 +717,7 @@ mod tests {
        let picks: Vec<String> = (1..=n)
            .map(|i| {
                format!(
-                    r#"{{"id":{i},"section":"Top Stories","position":{i},"lead_story":{},"why":"pick {i} because"}}"#,
+                    r#"{{"id":{i},"section":"Top Stories","position":{i},"lead_story":{}}}"#,
                    i == 1
                )
            })
@@ -809,34 +784,10 @@ mod tests {
        assert!(items[0].lead_story);
        assert_eq!(items[0].section, "Top Stories");
        assert_eq!(items.iter().filter(|i| i.lead_story).count(), 1);
-        assert!(items[0].why.as_deref().is_some_and(|w| !w.is_empty()));
        // Junk entries in the fixture are dropped, not fatal.
        assert!(items.iter().all(|i| i.id != 0));
    }

-    #[test]
-    fn why_lines_are_optional_and_capped_at_fourteen_words() {
-        let long = (1..=30)
-            .map(|i| format!("w{i}"))
-            .collect::<Vec<_>>()
-            .join(" ");
-        let items = parse_selection_response(&format!(
-            r#"{{"picks":[{{"id":1,"section":"Top Stories","why":"{long}"}},
-                          {{"id":2,"section":"Top Stories","why":"   "}},
-                          {{"id":3,"section":"Top Stories"}}]}}"#
-        ));
-        assert_eq!(items.len(), 3);
-        assert_eq!(
-            items[0]
-                .why
-                .as_deref()
-                .map(|w| w.split_whitespace().count()),
-            Some(14)
-        );
-        assert!(items[1].why.is_none());
-        assert!(items[2].why.is_none());
-    }
-
    #[test]
    fn the_prompt_substitutes_the_size_targets_and_renders_the_shortlist() {
        let prompt = build_prompt(&candidates(3), &sections(), 6, 11);
@@ -963,29 +914,6 @@ mod tests {
        assert!(prompt.contains("aim for about 6; never more than 11"));
    }

-    #[tokio::test]
-    async fn why_lines_land_on_picks() {
-        let backend = Arc::new(MockBackend::new());
-        backend.push(picks_json(3), TokenUsage::default());
-        let lineup = select(
-            &bulk_only(backend),
-            candidates(5),
-            &sections(),
-            3,
-            5,
-            date(),
-        )
-        .await
-        .expect("selection");
-        assert_eq!(lineup.picks.len(), 3);
-        for pick in &lineup.picks {
-            assert_eq!(
-                pick.why.as_deref(),
-                Some(format!("pick {} because", pick.article.id).as_str())
-            );
-        }
-    }
-
    #[tokio::test]
    async fn hallucinated_ids_and_missing_leads_are_repaired() {
        let backend = Arc::new(MockBackend::new());
@@ -1086,7 +1014,6 @@ mod tests {
            .find(|p| p.article.id == 30)
            .expect("reinserted");
        assert_eq!(reinserted.section, "From the Blogroll");
-        assert!(reinserted.why.is_some());
    }

    #[tokio::test]
@@ -1195,7 +1122,6 @@ mod tests {
        for pick in &lineup.picks {
            assert!(sections().contains(&pick.section));
            assert!(pick.summary.is_none());
-            assert!(pick.why.is_none());
        }
        assert!(!lineup.section_order.is_empty());
    }
@@ -275,10 +275,9 @@ pub fn build_brief_prompt(lineup: &Lineup, summaries: &BTreeMap<ArticleId, Strin
                .unwrap_or_else(|| excerpt_summary(pick));
            let _ = writeln!(
                prompt,
-                "- {}\n  feed: {}\n  why: {}\n  quality: {}\n  fit: {}\n  summary: {}",
+                "- {}\n  feed: {}\n  quality: {}\n  fit: {}\n  summary: {}",
                pick.article.title.trim(),
                pick.article.feed_title.trim(),
-                pick.why.as_deref().unwrap_or("not supplied"),
                quality,
                fit,
                summary
@@ -459,7 +458,6 @@ mod tests {
            section: section.into(),
            position: 1,
            is_lead,
-            why: Some(format!("the {title} piece you'd argue with")),
            summary: None,
            llm: None,
            top_interests: Vec::new(),
@@ -635,7 +633,6 @@ mod tests {
        assert!(prompt.contains("## Top Stories"));
        assert!(prompt.contains("## Boston & Local"));
        assert!(prompt.contains("- Migrating 40TB off Postgres"));
-        assert!(prompt.contains("why: the Migrating 40TB off Postgres piece you'd argue with"));
        assert!(prompt.contains("summary: A migration story with numbers."));
        assert!(prompt.contains("quality: unassessed"));
        assert!(prompt.contains("fit: unassessed"));
@@ -444,10 +444,10 @@ pub fn dot(left: &[f32], right: &[f32]) -> Result<f64, EmbeddingError> {

 /// The `limit` closest compatible cached article vectors, highest cosine first.
 ///
-/// A brute-force scan: the cache holds at most a few thousand rows after
-/// pruning, so one statement plus a sort is cheap. The caller supplies the
-/// target row's model, dimension and decoded vector so pages that already
-/// load that row do not query it a second time. Malformed candidate blobs are
+/// A brute-force scan of every compatible row: fine for the admin dashboard,
+/// too slow for reader pages (see [`crate::related`], which stores its
+/// results). The caller supplies the target row's model, dimension and decoded
+/// vector so pages that already load that row do not query it a second time. Malformed candidate blobs are
 /// ignored like malformed entries in the normal cache loader.
 pub async fn nearest_articles(
    db: &Db,
@@ -2,7 +2,7 @@
 //! the `explain` command and feature retention (plan §7.4–7.5, §15.2, §16).
 //!
 //! One row per considered article per run says where it stopped and why. Rows
-//! are upserted on every stage transition with every column set (never
+//! are upserted on every stage transition with every active field set (never
 //! `COALESCE`), so the last write for a run is the whole truth.

 use std::collections::BTreeMap;
@@ -45,16 +45,15 @@ pub struct CandidateRun<'a> {
    pub rank_utility: Option<i64>,
    pub cluster_id: Option<i64>,
    pub cluster_rank: Option<i64>,
-    pub editor_why: Option<&'a str>,
 }

-/// Upsert one row, setting every column (§7.4).
+/// Upsert one row, setting every active telemetry field (§7.4).
 pub async fn write(db: &Db, row: &CandidateRun<'_>) -> Result<(), sqlx::Error> {
    sqlx::query(
        "INSERT INTO candidate_runs
             (run_id, article_id, stage, excluded_reason, admitted_by, signals_json,
-              utility, rank_utility, cluster_id, cluster_rank, editor_why)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+              utility, rank_utility, cluster_id, cluster_rank)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
         ON CONFLICT(run_id, article_id) DO UPDATE SET
             stage = excluded.stage,
             excluded_reason = excluded.excluded_reason,
@@ -63,8 +62,7 @@ pub async fn write(db: &Db, row: &CandidateRun<'_>) -> Result<(), sqlx::Error> {
             utility = excluded.utility,
             rank_utility = excluded.rank_utility,
             cluster_id = excluded.cluster_id,
-             cluster_rank = excluded.cluster_rank,
-             editor_why = excluded.editor_why",
+             cluster_rank = excluded.cluster_rank",
    )
    .bind(row.run_id)
    .bind(row.article_id)
@@ -76,7 +74,6 @@ pub async fn write(db: &Db, row: &CandidateRun<'_>) -> Result<(), sqlx::Error> {
    .bind(row.rank_utility)
    .bind(row.cluster_id)
    .bind(row.cluster_rank)
-    .bind(row.editor_why)
    .execute(db.pool())
    .await?;
    Ok(())
@@ -103,7 +100,6 @@ pub async fn thin_excluded(
            rank_utility: None,
            cluster_id: None,
            cluster_rank: None,
-            editor_why: None,
        },
    )
    .await
@@ -236,7 +232,6 @@ pub struct ExplainRow {
    pub rank_utility: Option<i64>,
    pub cluster_id: Option<i64>,
    pub cluster_rank: Option<i64>,
-    pub editor_why: Option<String>,
 }

 impl ExplainRow {
@@ -254,7 +249,6 @@ impl ExplainRow {
            rank_utility: row.get("rank_utility"),
            cluster_id: row.get("cluster_id"),
            cluster_rank: row.get("cluster_rank"),
-            editor_why: row.get("editor_why"),
        }
    }

@@ -306,7 +300,7 @@ pub async fn explain_row(
        "SELECT cr.run_id, cr.article_id, COALESCE(a.title, '') AS title,
                COALESCE(e.feed_title, '') AS feed_title,
                cr.stage, cr.excluded_reason, cr.admitted_by, cr.signals_json,
-                cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank, cr.editor_why
+                cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank
         FROM candidate_runs cr JOIN articles a ON a.id = cr.article_id
         LEFT JOIN entries e ON e.id = a.best_entry_id
         WHERE cr.run_id = ? AND cr.article_id = ?",
@@ -329,7 +323,7 @@ pub async fn near_misses(
        "SELECT cr.run_id, cr.article_id, COALESCE(a.title, '') AS title,
                COALESCE(e.feed_title, '') AS feed_title,
                cr.stage, cr.excluded_reason, cr.admitted_by, cr.signals_json,
-                cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank, cr.editor_why
+                cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank
         FROM candidate_runs cr JOIN articles a ON a.id = cr.article_id
         LEFT JOIN entries e ON e.id = a.best_entry_id
         WHERE cr.run_id = ? AND cr.stage != 'selected' AND cr.stage != 'excluded'",
@@ -490,9 +484,6 @@ pub async fn render_explain(db: &Db, row: &ExplainRow) -> Result<String, sqlx::E
    if let Some(admitted_by) = &row.admitted_by {
        let _ = writeln!(out, "admitted by: {admitted_by}");
    }
-    if let Some(why) = &row.editor_why {
-        let _ = writeln!(out, "editor: {why}");
-    }
    Ok(out)
 }

@@ -1067,7 +1058,7 @@ pub fn render_stats_text(data: &StatsData) -> String {
 #[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub struct Pruned {
    /// `article_embeddings` of unrated, unpublished articles past
-    /// `embedding_retention_days`.
+    /// `embedding_retention_days`; always 0 when that is 0 (keep forever).
    pub embeddings: u64,
    /// `candidate_runs` rows of runs past `telemetry_retention_days`.
    pub telemetry: u64,
@@ -1076,7 +1067,8 @@ pub struct Pruned {
 }

 /// Delete `article_embeddings` for articles neither rated nor published that
-/// are older than `embedding_retention_days`, `candidate_runs` rows whose run
+/// are older than `embedding_retention_days` (0 or less keeps every vector, so
+/// related articles can reach the whole archive), `candidate_runs` rows whose run
 /// started more than `telemetry_retention_days` ago, and `article_assessments`
 /// older than the same window (§7.1, §7.4). Runs from `features prune` and
 /// once per `generate` after publishing.
@@ -1090,7 +1082,10 @@ pub async fn prune(
        now.checked_sub(jiff::Span::new().hours(days.max(0).saturating_mul(24)))
            .unwrap_or(Timestamp::UNIX_EPOCH)
    };
-    let embeddings = sqlx::query(
+    let embeddings = if embedding_retention_days <= 0 {
+        0
+    } else {
+        sqlx::query(
            "DELETE FROM article_embeddings
         WHERE article_id IN (
             SELECT ae.article_id
@@ -1103,7 +1098,8 @@ pub async fn prune(
        .bind(fmt_ts(cutoff(embedding_retention_days)))
        .execute(db.pool())
        .await?
-    .rows_affected();
+        .rows_affected()
+    };

    let telemetry = sqlx::query(
        "DELETE FROM candidate_runs
@@ -1255,7 +1251,6 @@ mod tests {
                rank_utility: None,
                cluster_id: None,
                cluster_rank: None,
-                editor_why: None,
            },
        )
        .await
@@ -1289,7 +1284,7 @@ mod tests {
    }

    #[tokio::test]
-    async fn rows_are_upserted_with_every_column_replaced() {
+    async fn rows_are_upserted_with_every_active_field_replaced() {
        let (_dir, db) = db_with_articles(&[1]).await;
        let run_id = db.start_run(date(), Timestamp::now()).await.unwrap();
        write(
@@ -1305,7 +1300,6 @@ mod tests {
                rank_utility: None,
                cluster_id: None,
                cluster_rank: None,
-                editor_why: None,
            },
        )
        .await
@@ -1323,7 +1317,6 @@ mod tests {
                rank_utility: None,
                cluster_id: None,
                cluster_rank: None,
-                editor_why: Some("because"),
            },
        )
        .await
@@ -1333,7 +1326,6 @@ mod tests {
        assert_eq!(row.excluded_reason, None, "no COALESCE");
        assert_eq!(row.utility, None);
        assert_eq!(row.admitted_by.as_deref(), Some("[\"prefilter\"]"));
-        assert_eq!(row.editor_why.as_deref(), Some("because"));
        let count: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM candidate_runs")
            .fetch_one(db.pool())
            .await
@@ -1360,7 +1352,6 @@ mod tests {
                rank_utility: None,
                cluster_id: None,
                cluster_rank: None,
-                editor_why: None,
            },
        )
        .await
@@ -1493,7 +1484,6 @@ mod tests {
                    rank_utility: None,
                    cluster_id: None,
                    cluster_rank: None,
-                    editor_why: None,
                },
            )
            .await
@@ -1582,7 +1572,6 @@ mod tests {
                rank_utility: Some(3),
                cluster_id: None,
                cluster_rank: None,
-                editor_why: None,
            },
        )
        .await
@@ -1600,7 +1589,6 @@ mod tests {
                rank_utility: Some(1),
                cluster_id: None,
                cluster_rank: None,
-                editor_why: Some("because"),
            },
        )
        .await
@@ -1697,7 +1685,6 @@ mod tests {
                    rank_utility: None,
                    cluster_id: None,
                    cluster_rank: None,
-                    editor_why: None,
                },
            )
            .await
@@ -1960,4 +1947,39 @@ mean generation time: n/a (0 runs)
        // A second pass finds nothing left to remove.
        assert_eq!(prune(&db, 120, 180, now).await.unwrap(), Pruned::default());
    }
+
+    #[tokio::test]
+    async fn zero_embedding_retention_keeps_every_vector() {
+        let (_dir, db) = db_with_articles(&[1, 2]).await;
+        let now = Timestamp::now();
+        let old = fmt_ts(now - jiff::Span::new().hours(2000 * 24));
+        sqlx::query("UPDATE articles SET first_seen = ?")
+            .bind(&old)
+            .execute(db.pool())
+            .await
+            .unwrap();
+        let blob = encode_blob(&[0.5, 0.5]).unwrap();
+        for id in 1..=2 {
+            sqlx::query(
+                "INSERT INTO article_embeddings
+                     (article_id, model, dimension, input_hash, embedding, created_at)
+                 VALUES (?, 'voyage-4-lite', 2, 'h', ?, ?)",
+            )
+            .bind(id)
+            .bind(&blob)
+            .bind(&old)
+            .execute(db.pool())
+            .await
+            .unwrap();
+        }
+
+        // 0 must not mean "a cutoff of now", which would delete everything.
+        let pruned = prune(&db, 0, 180, now).await.unwrap();
+        assert_eq!(pruned.embeddings, 0);
+        let remaining: i64 = sqlx::query_scalar("SELECT COUNT(*) FROM article_embeddings")
+            .fetch_one(db.pool())
+            .await
+            .unwrap();
+        assert_eq!(remaining, 2);
+    }
 }
@@ -606,8 +606,8 @@ impl Db {
            .await?;
        for pick in picks {
            sqlx::query(
-                "INSERT INTO issue_articles (issue_date, article_id, section, position, is_lead, summary, why)
-                 VALUES (?, ?, ?, ?, ?, ?, ?)",
+                "INSERT INTO issue_articles (issue_date, article_id, section, position, is_lead, summary)
+                 VALUES (?, ?, ?, ?, ?, ?)",
            )
            .bind(date.to_string())
            .bind(pick.article.id)
@@ -615,7 +615,6 @@ impl Db {
            .bind(pick.position)
            .bind(pick.is_lead)
            .bind(pick.summary.as_deref())
-            .bind(pick.why.as_deref())
            .execute(&mut *tx)
            .await?;
        }
@@ -42,7 +42,6 @@ struct IndexEntry {
    source: String,
    reading_minutes: i64,
    summary: String,
-    why: Option<String>,
    understanding: Understanding,
 }

@@ -82,7 +81,6 @@ struct ArticleChapter {
    meta_line: String,
    social_line: Option<String>,
    understanding: Understanding,
-    why: Option<String>,
    summary: Option<String>,
    excerpt_only: bool,
    body_html: String,
@@ -152,9 +150,10 @@ struct ProviderCostLine {

 /// Prepare article markup for XHTML: rewrite images, sanitize, self-close voids.
 pub fn prepare_body(html: &str, images_: &[ImageAsset]) -> String {
-    // Sanitize first: image rewriting emits our own trusted markup (including the
-    // `image-placeholder` class, which ammonia would otherwise strip).
-    let cleaned = ammonia::clean(html);
+    // Sanitize first: highlighting and image rewriting emit our own trusted
+    // markup (the `hl-*` token classes and `image-placeholder`, which ammonia
+    // would otherwise strip).
+    let cleaned = crate::highlight::clean_and_highlight(html);
    let rewritten = images::rewrite_img_srcs(&cleaned, images_);
    to_xhtml(&rewritten)
 }
@@ -241,17 +240,6 @@ pub struct InterestRef {
    pub href: String,
 }

-impl Understanding {
-    /// EPUBs keep interest names as plain text, without dashboard links.
-    pub fn interests_line(&self) -> String {
-        self.interests
-            .iter()
-            .map(|interest| interest.name.as_str())
-            .collect::<Vec<_>>()
-            .join(" \u{00b7} ")
-    }
-}
-
 /// Reader-facing assessment details, split so templates can give each part the
 /// same editorial hierarchy across web and EPUB surfaces.
 pub fn understanding(pick: &Pick) -> Understanding {
@@ -411,7 +399,6 @@ pub fn render_in_this_issue(issue: &Issue) -> Result<Chapter, EpubError> {
                source: index_source_line(&pick.article),
                reading_minutes: pick.article.reading_minutes(),
                summary: summary_for(issue, pick).unwrap_or_default().to_string(),
-                why: pick.why.clone(),
                understanding: understanding(pick),
            })
            .collect();
@@ -426,7 +413,6 @@ pub fn render_in_this_issue(issue: &Issue) -> Result<Chapter, EpubError> {
                source: "Wikipedia Current Events".into(),
                reading_minutes: 3,
                summary: "The day's events, as recorded by the Current Events portal.".into(),
-                why: None,
                understanding: Understanding::default(),
            }],
        });
@@ -504,7 +490,6 @@ pub fn render_article(
        meta_line: meta_parts.join(" \u{00b7} "),
        social_line: social_line(&article.social),
        understanding: understanding(pick),
-        why: pick.why.clone(),
        summary: summary_for(issue, pick).map(str::to_string),
        excerpt_only: article.excerpt_only,
        body_html: prepare_body(&article.content_html, images_),
@@ -924,7 +909,21 @@ mod tests {
        // The lead's rubric and matches are on the index; the second pick has neither.
        assert_eq!(chapter.xhtml.matches("class=\"rubric\"").count(), 1);
        assert!(chapter.xhtml.contains("Software engineering · Analysis"));
-        assert!(chapter.xhtml.contains("Matches: Filesystems · Rust"));
+        assert!(
+            chapter
+                .xhtml
+                .contains("<span class=\"interest\">Filesystems</span>")
+        );
+        assert!(
+            chapter
+                .xhtml
+                .contains("<span class=\"interest\">Rust</span>")
+        );
+        let rubric_position = chapter.xhtml.find("class=\"rubric\"").unwrap();
+        let matches_position = chapter.xhtml.find("class=\"matches\"").unwrap();
+        let summary_position = chapter.xhtml.find("class=\"index-summary\"").unwrap();
+        assert!(rubric_position < matches_position);
+        assert!(matches_position < summary_position);
        // Titles are escaped (askama emits numeric references), never injected raw.
        assert!(chapter.xhtml.contains("A Niche Delight &#38; Other Tales"));
        assert_xml_ok(&chapter.xhtml);
@@ -997,11 +996,22 @@ mod tests {
        assert!(chapter.xhtml.contains("class=\"rubric\""));
        assert!(chapter.xhtml.contains("Software engineering · Analysis"));
        assert!(chapter.xhtml.contains("copy-on-write · ZFS"));
-        assert!(chapter.xhtml.contains("Matches: Filesystems · Rust"));
+        assert!(
+            chapter
+                .xhtml
+                .contains("<span class=\"interest\">Filesystems</span>")
+        );
+        assert!(
+            chapter
+                .xhtml
+                .contains("<span class=\"interest\">Rust</span>")
+        );
        let rubric_position = chapter.xhtml.find("class=\"rubric\"").unwrap();
+        let matches_position = chapter.xhtml.find("class=\"matches\"").unwrap();
        let summary_position = chapter.xhtml.find("class=\"summary\"").unwrap();
        let social_position = chapter.xhtml.find("class=\"social\"").unwrap();
-        assert!(rubric_position < summary_position);
+        assert!(rubric_position < matches_position);
+        assert!(matches_position < summary_position);
        assert!(summary_position < social_position);
        let footer = chapter
            .xhtml
@@ -1009,7 +1019,7 @@ mod tests {
            .unwrap()
            .1;
        assert!(!footer.contains("class=\"rubric\""));
-        assert!(!footer.contains("Matches:"));
+        assert!(!footer.contains("class=\"matches\""));
        let second = render_article(
            &issue,
            &issue.lineup.picks[1],
@@ -87,7 +87,6 @@ pub fn issue() -> Issue {
        section: "Top Stories".into(),
        position: 0,
        is_lead: true,
-        why: Some("The systems story with enough operational detail to matter".into()),
        summary: Some("What it argues, and why it is worth the time.".into()),
        llm: Some(Deep {
            quality: 9.0,
@@ -115,7 +114,6 @@ pub fn issue() -> Issue {
        section: "Niche Corner".into(),
        position: 0,
        is_lead: false,
-        why: Some("A small-scene delight outside the usual technical orbit".into()),
        summary: None,
        llm: None,
        top_interests: Vec::new(),
@@ -10,15 +10,8 @@
 {% if understanding.kicker.is_some() || understanding.topics.is_some() %}
        <p class="rubric">{% if let Some(kicker) = understanding.kicker %}<span class="kicker">{{ kicker }}</span>{% if let Some(topics) = understanding.topics %} &#160; {{ topics }}{% endif %}{% else %}{% if let Some(topics) = understanding.topics %}{{ topics }}{% endif %}{% endif %}</p>
 {% endif %}
-{% if why.is_some() || !understanding.interests.is_empty() %}
-        <div class="why">
-{% if let Some(text) = why %}
-          <p class="why-line"><em>Why it&#39;s here: {{ text }}</em></p>
-{% endif %}
 {% if !understanding.interests.is_empty() %}
-          <p class="why-matches">Matches: {{ understanding.interests_line() }}</p>
-{% endif %}
-        </div>
+        <p class="matches">{% for interest in understanding.interests %}{% if !loop.first %}<span class="sep">|</span>{% endif %}<span class="interest">{{ interest.name }}</span>{% endfor %}</p>
 {% endif %}
 {% if let Some(text) = summary %}
        <p class="summary">{{ text }}</p>
@@ -13,15 +13,8 @@
 {% if entry.understanding.kicker.is_some() || entry.understanding.topics.is_some() %}
          <p class="rubric">{% if let Some(kicker) = entry.understanding.kicker %}<span class="kicker">{{ kicker }}</span>{% if let Some(topics) = entry.understanding.topics %} &#160; {{ topics }}{% endif %}{% else %}{% if let Some(topics) = entry.understanding.topics %}{{ topics }}{% endif %}{% endif %}</p>
 {% endif %}
-{% if entry.why.is_some() || !entry.understanding.interests.is_empty() %}
-          <div class="index-why">
-{% if let Some(text) = entry.why %}
-            <p class="why-line"><em>Why it&#39;s here: {{ text }}</em></p>
-{% endif %}
 {% if !entry.understanding.interests.is_empty() %}
-            <p class="why-matches">Matches: {{ entry.understanding.interests_line() }}</p>
-{% endif %}
-          </div>
+          <p class="matches">{% for interest in entry.understanding.interests %}{% if !loop.first %}<span class="sep">|</span>{% endif %}<span class="interest">{{ interest.name }}</span>{% endfor %}</p>
 {% endif %}
 {% if !entry.summary.is_empty() %}
          <p class="index-summary">{{ entry.summary }}</p>
@@ -95,22 +95,17 @@ img {
  font-variant: small-caps;
 }

-.why,
-.index-why {
+.matches {
  margin: 0.2em 0 0 0;
-  font-size: 0.9em;
-}
-
-.why-line {
-  margin: 0;
-}
-
-.why-matches {
-  margin: 0;
  font-size: 0.85em;
  color: #444444;
 }

+.sep {
+  color: #888888;
+  padding: 0 0.4em;
+}
+
 .dateline,
 .stats {
  text-align: center;
@@ -165,7 +160,16 @@ figcaption,
  text-align: center;
 }

-pre, code {
+/* The firmwares (CrossPoint, CrossInk) ignore `white-space` and treat `pre`
+   as inline, so the X4 simplifier makes each listing line a `p.code-line`;
+   the first and last lines carry the block's spacing, and a blank source
+   line becomes a `p.code-gap` margin. `figure` centres for
+   image captions, so lines reset alignment. The XTC converter's CREngine
+   defaults `code` to a block. */
+pre {
+  display: block;
+  margin: 0;
+  text-align: left;
  font-family: monospace;
  font-size: 0.85em;
  white-space: pre-wrap;
@@ -174,6 +178,81 @@ pre, code {
  -webkit-hyphens: none;
 }

+p.code-line {
+  margin: 0;
+  text-indent: 0;
+  text-align: left;
+  hyphens: none;
+  -webkit-hyphens: none;
+}
+
+p.code-first {
+  margin-top: 0.6em;
+}
+
+p.code-last {
+  margin-bottom: 0.6em;
+}
+
+/* Where the source had a blank line: half a line, not a whole one. */
+p.code-gap {
+  margin-bottom: 0.5em;
+}
+
+code {
+  display: inline;
+  font-family: monospace;
+  font-size: 0.85em;
+  hyphens: none;
+  -webkit-hyphens: none;
+}
+
+/* Syntax tokens (src/highlight.rs), as in style.css but on the X4's four
+   levels only (#000, #555, #aaa, white), so glyphs are not dithered: ink for
+   names, dark grey for keywords, literals and punctuation, light grey for
+   comments. */
+.hl-function,
+.hl-macro,
+.hl-title,
+.hl-strong {
+  font-weight: bold;
+}
+
+.hl-type,
+.hl-namespace,
+.hl-constructor,
+.hl-attribute,
+.hl-emphasis {
+  font-style: italic;
+}
+
+.hl-keyword,
+.hl-tag {
+  font-weight: bold;
+  color: #555555;
+}
+
+.hl-string {
+  color: #555555;
+}
+
+.hl-number,
+.hl-constant,
+.hl-label {
+  font-style: italic;
+  color: #555555;
+}
+
+.hl-punctuation,
+.hl-operator {
+  color: #555555;
+}
+
+.hl-comment {
+  font-style: italic;
+  color: #aaaaaa;
+}
+
 table {
  border-collapse: collapse;
  font-size: 0.85em;
@@ -160,22 +160,19 @@ hr.rule {
  color: #444444;
 }

-.why,
-.index-why {
-  margin: 0.35em 0 0 0;
-  font-size: 0.9em;
-}
-
-.why-line {
-  margin: 0;
-}
-
-.why-matches {
-  margin: 0.1em 0 0 0;
-  font-size: 0.85em;
+/* Matched interests read like the rubric's topics, with a muted vertical
+   bar between them instead of the topics' dot. */
+.matches {
+  margin: 0.2em 0 0 0;
+  font-size: 0.8em;
  color: #444444;
 }

+.sep {
+  color: #aaaaaa;
+  padding: 0 0.4em;
+}
+
 .summary {
  margin: 0.5em 0 0 0;
  font-style: italic;
@@ -224,13 +221,67 @@ hr.rule {
  font-size: 0.85em;
 }

+/* CREngine readers (KOReader, PocketBook) default `code` to a block. */
+.article-body code {
+  display: inline;
+}
+
+/* Left even inside a `<figure>`, which centres for image captions. */
 .article-body pre {
+  margin: 0.8em 0;
+  text-align: left;
  white-space: pre-wrap;
  word-wrap: break-word;
  border-left: 2px solid #cccccc;
  padding-left: 0.5em;
 }

+/* Syntax tokens (src/highlight.rs), monochrome for e-ink, after zenbones and
+   lackluster: what the code names stays in ink (functions bold, types italic),
+   the language's own furniture steps back to grey (keywords bold grey,
+   literals and punctuation grey), comments lightest. Flat selectors. */
+.hl-function,
+.hl-macro,
+.hl-title,
+.hl-strong {
+  font-weight: bold;
+}
+
+.hl-type,
+.hl-namespace,
+.hl-constructor,
+.hl-attribute,
+.hl-emphasis {
+  font-style: italic;
+}
+
+.hl-keyword,
+.hl-tag {
+  font-weight: bold;
+  color: #555555;
+}
+
+.hl-string {
+  color: #555555;
+}
+
+.hl-number,
+.hl-constant,
+.hl-label {
+  font-style: italic;
+  color: #555555;
+}
+
+.hl-punctuation,
+.hl-operator {
+  color: #666666;
+}
+
+.hl-comment {
+  font-style: italic;
+  color: #888888;
+}
+
 .article-body table {
  border-collapse: collapse;
  font-size: 0.85em;
@@ -124,10 +124,295 @@ fn is_dropped_declaration(decl: &str) -> bool {
    false
 }

+/// Class of every paragraph [`paragraph_code_lines`] makes from a listing
+/// line; the first and last also get [`CODE_FIRST_CLASS`] / [`CODE_LAST_CLASS`].
+pub const CODE_LINE_CLASS: &str = "code-line";
+pub const CODE_FIRST_CLASS: &str = "code-first";
+pub const CODE_LAST_CLASS: &str = "code-last";
+/// Marks a line followed by blank lines in the source; it gets a short gap.
+pub const CODE_GAP_CLASS: &str = "code-gap";
+
 /// Strip layout constructs the X4 renderer handles poorly from chapter markup,
 /// then soft-hyphenate anything too long for it to wrap (§3.10).
 pub fn simplify_xhtml(xhtml: &str) -> String {
-    break_long_words(&strip_attributes(xhtml, DROPPED_ATTRIBUTES))
+    paragraph_code_lines(&break_long_words(&strip_attributes(
+        &flatten_lossy_tables(xhtml),
+        DROPPED_ATTRIBUTES,
+    )))
+}
+
+/// Table elements dropped outright when an image table is flattened.
+const TABLE_FRAME_ELEMENTS: &[&str] =
+    &["table", "thead", "tbody", "tfoot", "tr", "colgroup", "col"];
+
+/// Table elements whose content becomes a `<div>` when a table is flattened.
+const TABLE_CELL_ELEMENTS: &[&str] = &["td", "th", "caption"];
+
+/// Elements the X4 firmwares treat as images.
+const IMAGE_ELEMENTS: &[&str] = &["img", "image"];
+
+/// Turn every table the X4 firmwares would lose content from into plain
+/// `<div>` blocks: one that holds an image or another table.
+///
+/// The firmwares (CrossPoint and CrossInk) never draw an image inside a table
+/// cell: they print its alt text instead. Publishers that lay out a figure as a
+/// one-cell table with the caption beneath the image (The Space Review, many
+/// older sites) would lose every figure. CrossInk also throws away all the text
+/// of a table nested in another. Flattening keeps each cell's content in order,
+/// which is how the firmwares already fall back for any table they cannot lay
+/// out as a grid. Tables of plain text stay tables.
+fn flatten_lossy_tables(html: &str) -> String {
+    let mut out = String::with_capacity(html.len());
+    let mut cursor = 0usize;
+    while let Some(rel) = html[cursor..].find('<') {
+        let start = cursor + rel;
+        out.push_str(&html[cursor..start]);
+        let Some(end) = tag_end(html, start) else {
+            out.push_str(&html[start..]);
+            return out;
+        };
+        let tag = &html[start..end];
+        if let Some(name) = raw_text_name(tag) {
+            let close = find_close_tag(html, end, name).unwrap_or(html.len());
+            out.push_str(&html[start..close]);
+            cursor = close;
+            continue;
+        }
+        if !is_element_tag(tag, "table", false) {
+            out.push_str(tag);
+            cursor = end;
+            continue;
+        }
+        let table_end = matching_table_end(html, start);
+        let table = &html[start..table_end];
+        // Past the outer `<table` tag, so it doesn't count as its own nesting.
+        let inner = &table[end - start..];
+        if contains_element(inner, IMAGE_ELEMENTS) || contains_element(inner, &["table"]) {
+            out.push_str(&flatten_table(table));
+        } else {
+            out.push_str(table);
+        }
+        cursor = table_end;
+    }
+    out.push_str(&html[cursor..]);
+    out
+}
+
+/// Byte offset just past the `</table>` that closes the table opened at
+/// `start`, counting nested tables; the end of `html` if it is never closed.
+fn matching_table_end(html: &str, start: usize) -> usize {
+    let mut depth = 0usize;
+    let mut cursor = start;
+    while let Some(rel) = html[cursor..].find('<') {
+        let tag_start = cursor + rel;
+        let Some(end) = tag_end(html, tag_start) else {
+            break;
+        };
+        let tag = &html[tag_start..end];
+        if is_element_tag(tag, "table", false) && !tag.ends_with("/>") {
+            depth += 1;
+        } else if is_element_tag(tag, "table", true) {
+            depth = depth.saturating_sub(1);
+            if depth == 0 {
+                return end;
+            }
+        }
+        cursor = end;
+    }
+    html.len()
+}
+
+/// Whether any tag in `html` opens one of the named elements.
+fn contains_element(html: &str, names: &[&str]) -> bool {
+    let mut cursor = 0usize;
+    while let Some(rel) = html[cursor..].find('<') {
+        let start = cursor + rel;
+        let Some(end) = tag_end(html, start) else {
+            return false;
+        };
+        let tag = &html[start..end];
+        if names.iter().any(|name| is_element_tag(tag, name, false)) {
+            return true;
+        }
+        cursor = end;
+    }
+    false
+}
+
+/// Rewrite one table's markup (nested tables included) as `<div>` blocks.
+fn flatten_table(table: &str) -> String {
+    let mut out = String::with_capacity(table.len());
+    let mut cursor = 0usize;
+    while let Some(rel) = table[cursor..].find('<') {
+        let start = cursor + rel;
+        out.push_str(&table[cursor..start]);
+        let Some(end) = tag_end(table, start) else {
+            out.push_str(&table[start..]);
+            return out;
+        };
+        let tag = &table[start..end];
+        cursor = end;
+        let is = |names: &[&str], closing: bool| {
+            names.iter().any(|name| is_element_tag(tag, name, closing))
+        };
+        if is(TABLE_FRAME_ELEMENTS, false) || is(TABLE_FRAME_ELEMENTS, true) {
+            // A newline, not nothing: the firmwares buffer the last word
+            // before an element boundary until whitespace arrives.
+            out.push('\n');
+        } else if is(TABLE_CELL_ELEMENTS, false) {
+            out.push_str(if tag.ends_with("/>") {
+                "<div></div>"
+            } else {
+                "<div>"
+            });
+        } else if is(TABLE_CELL_ELEMENTS, true) {
+            out.push_str("</div>");
+        } else {
+            out.push_str(tag);
+        }
+    }
+    out.push_str(&table[cursor..]);
+    out
+}
+
+/// Turn each line of every `<pre>` into its own `<p class="code-line">`.
+///
+/// The X4 firmwares (CrossPoint and forks such as CrossInk) ignore
+/// `white-space` and lay out only `p`, `div`, `li`, `blockquote`, lists and
+/// `br` as blocks: a `<pre>` is inline, so its margins never apply and its
+/// `<br/>` lines are handled by each firmware's own rules. CrossInk glues the
+/// first line onto the paragraph before, and empty `<br/>` lines count as scene
+/// breaks. A paragraph per line takes the one path every firmware lays out the
+/// same way. The first and last lines carry the block's margins; blank lines
+/// become a half-line gap (see [`code_paragraphs`]).
+///
+/// Inline elements open across a line break (a `<code>`, a multi-line
+/// comment's span) are closed at the end of the line and reopened at the start
+/// of the next, so every paragraph is well formed.
+fn paragraph_code_lines(html: &str) -> String {
+    let mut out = String::with_capacity(html.len() + 256);
+    let mut cursor = 0usize;
+    while let Some(rel) = html[cursor..].find('<') {
+        let start = cursor + rel;
+        out.push_str(&html[cursor..start]);
+        let Some(end) = tag_end(html, start) else {
+            out.push_str(&html[start..]);
+            return out;
+        };
+        let tag = &html[start..end];
+        out.push_str(tag);
+        cursor = end;
+        if !is_element_tag(tag, "pre", false) {
+            continue;
+        }
+        let Some(close) = find_close_tag(html, cursor, "pre") else {
+            continue;
+        };
+        out.push_str(&code_paragraphs(&html[cursor..close]));
+        cursor = close;
+    }
+    out.push_str(&html[cursor..]);
+    out
+}
+
+/// The paragraphs for one `<pre>` body whose line breaks are `<br/>`.
+fn code_paragraphs(body: &str) -> String {
+    // Each line's markup, plus whether it shows any text.
+    let mut lines: Vec<(String, bool)> = Vec::new();
+    // Inline elements open at this point: (name, opening tag).
+    let mut open: Vec<(String, &str)> = Vec::new();
+    let mut line = String::new();
+    let mut visible = false;
+    let mut cursor = 0usize;
+    let finish = |line: &mut String, visible: &mut bool, open: &[(String, &str)]| {
+        let mut done = std::mem::take(line);
+        if !*visible {
+            done.push(NO_BREAK_SPACE);
+        }
+        for (name, _) in open.iter().rev() {
+            done.push_str(&format!("</{name}>"));
+        }
+        let shown = std::mem::replace(visible, false);
+        for (_, tag) in open {
+            line.push_str(tag);
+        }
+        (done, shown)
+    };
+    while cursor < body.len() {
+        let Some(rel) = body[cursor..].find('<') else {
+            let text = &body[cursor..];
+            visible |= shows_text(text);
+            line.push_str(text);
+            break;
+        };
+        let start = cursor + rel;
+        let text = &body[cursor..start];
+        visible |= shows_text(text);
+        line.push_str(text);
+        let Some(end) = tag_end(body, start) else {
+            line.push_str(&body[start..]);
+            break;
+        };
+        let tag = &body[start..end];
+        cursor = end;
+        let inner = tag.trim_start_matches('<').trim_end_matches('>');
+        let name = crate::html::tag_name(inner);
+        if name == "br" {
+            lines.push(finish(&mut line, &mut visible, &open));
+        } else if inner.starts_with('/') {
+            if let Some(at) = open.iter().rposition(|(open_name, _)| *open_name == name) {
+                open.remove(at);
+            }
+            line.push_str(tag);
+        } else {
+            if !inner.trim_end().ends_with('/') {
+                open.push((name, tag));
+            }
+            line.push_str(tag);
+        }
+    }
+    lines.push(finish(&mut line, &mut visible, &open));
+    // Blank lines become a short gap after the line before them rather than
+    // paragraphs of their own: with the firmware's paragraph spacing on, a
+    // blank paragraph adds a full line plus two half-line gaps and reads as a
+    // double newline. Leading, trailing and repeated blanks collapse.
+    let mut kept: Vec<(String, bool)> = Vec::with_capacity(lines.len());
+    for (line, shown) in lines {
+        if shown {
+            kept.push((line, false));
+        } else if let Some(previous) = kept.last_mut() {
+            previous.1 = true;
+        }
+    }
+    if kept.is_empty() {
+        // An all-blank listing still occupies one line.
+        kept.push((NO_BREAK_SPACE.to_string(), false));
+    }
+
+    let last = kept.len() - 1;
+    let mut out = String::with_capacity(body.len() + kept.len() * 48);
+    for (index, (line, gap_after)) in kept.into_iter().enumerate() {
+        let mut class = String::from(CODE_LINE_CLASS);
+        if index == 0 {
+            class.push(' ');
+            class.push_str(CODE_FIRST_CLASS);
+        }
+        if index == last {
+            class.push(' ');
+            class.push_str(CODE_LAST_CLASS);
+        } else if gap_after {
+            class.push(' ');
+            class.push_str(CODE_GAP_CLASS);
+        }
+        out.push_str(&format!("<p class=\"{class}\">{line}</p>"));
+    }
+    out
+}
+
+/// Whether a run of character data shows anything but spaces.
+fn shows_text(text: &str) -> bool {
+    text.chars()
+        .any(|c| !c.is_whitespace() && c != NO_BREAK_SPACE)
 }

 /// Insert soft hyphens into over-long words and make `<pre>` whitespace
@@ -609,7 +894,7 @@ mod tests {
    #[test]
    fn pre_whitespace_is_made_explicit_inside_nested_tags() {
        let input = "<pre><code>fn main() {\n    if x &lt; 2 {\n        <em>return</em>;\n    }\n <strong><a href=\"#\">// done</a></strong>\n}</code></pre>";
-        let out = simplify_xhtml(input);
+        let out = break_long_words(input);
        assert_eq!(
            out,
            concat!(
@@ -622,10 +907,40 @@ mod tests {
        );
    }

+    #[test]
+    fn each_code_line_becomes_a_paragraph() {
+        let input = "<p>Before.</p><figure><pre><code>let a = 1;\n\n  let b = 2;</code></pre></figure><p>After.</p>";
+        assert_eq!(
+            simplify_xhtml(input),
+            concat!(
+                "<p>Before.</p><figure><pre>",
+                "<p class=\"code-line code-first code-gap\"><code>let a = 1;</code></p>",
+                "<p class=\"code-line code-last\"><code>\u{00a0}\u{00a0}let b = 2;</code></p>",
+                "</pre></figure><p>After.</p>"
+            )
+        );
+        // `<pre` as a prefix of another name is not a code block.
+        assert_eq!(simplify_xhtml("<prefix>x</prefix>"), "<prefix>x</prefix>");
+    }
+
+    #[test]
+    fn spans_open_across_a_line_break_are_closed_and_reopened() {
+        let input = "<pre><code><span class=\"hl-comment\">/* one\ntwo */</span> x\n</code></pre>";
+        assert_eq!(
+            simplify_xhtml(input),
+            concat!(
+                "<pre>",
+                "<p class=\"code-line code-first\"><code><span class=\"hl-comment\">/* one</span></code></p>",
+                "<p class=\"code-line code-last\"><code><span class=\"hl-comment\">two */</span> x</code></p>",
+                "</pre>"
+            )
+        );
+    }
+
    #[test]
    fn tabs_in_pre_become_four_no_break_spaces() {
        assert_eq!(
-            simplify_xhtml("<pre><code>one\ttwo</code></pre>"),
+            break_long_words("<pre><code>one\ttwo</code></pre>"),
            "<pre><code>one\u{00a0}\u{00a0}\u{00a0}\u{00a0}two</code></pre>"
        );
    }
@@ -634,7 +949,7 @@ mod tests {
    fn whitespace_outside_pre_is_untouched() {
        let input = "<p>outside  text\n next\tword</p><pre>x  y</pre><p>tail  text</p>";
        assert_eq!(
-            simplify_xhtml(input),
+            break_long_words(input),
            "<p>outside  text\n next\tword</p><pre>x\u{00a0}\u{00a0}y</pre><p>tail  text</p>"
        );
    }
@@ -642,11 +957,11 @@ mod tests {
    #[test]
    fn newline_right_after_pre_open_is_not_a_blank_line() {
        assert_eq!(
-            simplify_xhtml("<pre><code>\nlet a = 1;\n\nlet b = 2;</code></pre>"),
+            break_long_words("<pre><code>\nlet a = 1;\n\nlet b = 2;</code></pre>"),
            "<pre><code>let a = 1;<br/><br/>let b = 2;</code></pre>"
        );
        assert_eq!(
-            simplify_xhtml("<pre>\n  x</pre>"),
+            break_long_words("<pre>\n  x</pre>"),
            "<pre>\u{00a0}\u{00a0}x</pre>"
        );
    }
@@ -654,7 +969,7 @@ mod tests {
    #[test]
    fn pre_without_a_trailing_newline_gets_no_extra_break() {
        let input = "<pre><code>let answer = 42;</code></pre>";
-        assert_eq!(simplify_xhtml(input), input);
+        assert_eq!(break_long_words(input), input);
    }

    /// The shipped X4 stylesheet must already satisfy the X4 rules, so the
@@ -794,4 +1109,97 @@ mod tests {
            "<?xml version=\"1.0\"?>\n<!DOCTYPE html>\n<html><body><p>2 &lt; 3</p></body></html>";
        assert_eq!(simplify_xhtml(input), input);
    }
+
+    /// Whether any image in `html` sits inside a table, where the X4
+    /// firmwares print its alt text instead of drawing it.
+    fn image_inside_table(html: &str) -> bool {
+        let mut depth = 0usize;
+        let mut cursor = 0usize;
+        while let Some(rel) = html[cursor..].find('<') {
+            let start = cursor + rel;
+            let end = tag_end(html, start).unwrap();
+            let tag = &html[start..end];
+            if is_element_tag(tag, "table", false) {
+                depth += 1;
+            } else if is_element_tag(tag, "table", true) {
+                depth -= 1;
+            } else if depth > 0 && IMAGE_ELEMENTS.iter().any(|n| is_element_tag(tag, n, false)) {
+                return true;
+            }
+            cursor = end;
+        }
+        false
+    }
+
+    #[test]
+    fn a_figure_laid_out_as_a_table_becomes_divs() {
+        // The Space Review's figure markup (issue 2026-10-01).
+        let input = "<p>Before.</p><table><tbody><tr><td><img src=\"images/a.jpg\" alt=\"ELINT images\"/><p>During the 1970s. (credit: NRO)</p></td></tr></tbody></table><h3>Next</h3>";
+        let out = simplify_xhtml(input);
+        assert!(!image_inside_table(&out), "{out}");
+        assert!(!out.contains("<t"), "{out}");
+        assert!(
+            out.contains("<div><img src=\"images/a.jpg\" alt=\"ELINT images\"/><p>During the 1970s. (credit: NRO)</p></div>"),
+            "{out}"
+        );
+        assert!(
+            out.starts_with("<p>Before.</p>") && out.ends_with("<h3>Next</h3>"),
+            "{out}"
+        );
+    }
+
+    #[test]
+    fn every_cell_of_an_image_table_keeps_its_content_in_order() {
+        let input = "<table class=\"x\" width=\"600\"><caption>Cap</caption><thead><tr><th>A</th><th>B</th></tr></thead><tr><td colspan=\"2\"><img src=\"1.jpg\"/></td></tr><tr><td>left</td><td>right</td></tr></table>";
+        let out = flatten_lossy_tables(input);
+        assert_eq!(
+            out.split_whitespace().collect::<String>(),
+            "<div>Cap</div><div>A</div><div>B</div><div><imgsrc=\"1.jpg\"/></div><div>left</div><div>right</div>"
+        );
+    }
+
+    #[test]
+    fn nested_image_tables_flatten_from_the_outside_in() {
+        for input in [
+            // Image in the inner table only.
+            "<table><tr><td><table><tr><td><img src=\"1.jpg\"/></td></tr></table></td></tr></table><p>after</p>",
+            // Image in the outer table after a text-only inner table.
+            "<table><tr><td><table><tr><td>x</td></tr></table><img src=\"1.jpg\"/></td></tr></table><p>after</p>",
+            // An SVG `<image>` counts too.
+            "<table><tr><td><svg><image href=\"1.jpg\"/></svg></td></tr></table><p>after</p>",
+        ] {
+            let out = simplify_xhtml(input);
+            assert!(!image_inside_table(&out), "{out}");
+            assert!(!out.contains("<table"), "{out}");
+            assert!(out.ends_with("<p>after</p>"), "{out}");
+        }
+    }
+
+    #[test]
+    fn a_nested_text_table_flattens_its_outer_table() {
+        let input = "<table><tr><td>outer<table><tr><td>inner</td></tr></table></td></tr></table>";
+        let out = flatten_lossy_tables(input);
+        assert_eq!(
+            out.split_whitespace().collect::<String>(),
+            "<div>outer<div>inner</div></div>"
+        );
+    }
+
+    #[test]
+    fn text_tables_stay_tables() {
+        let input = "<table><tr><th>Year</th><td>1971</td></tr></table><p><img src=\"1.jpg\"/></p><table><tr><td>2</td></tr></table>";
+        assert_eq!(flatten_lossy_tables(input), input);
+    }
+
+    #[test]
+    fn table_markup_inside_raw_text_is_left_alone() {
+        let input = "<script>let t = '<table><td><img src=x></td></table>';</script>";
+        assert_eq!(flatten_lossy_tables(input), input);
+    }
+
+    #[test]
+    fn an_unclosed_image_table_still_flattens() {
+        let out = flatten_lossy_tables("<table><tr><td><img src=\"1.jpg\"/>");
+        assert!(!image_inside_table(&out), "{out}");
+    }
 }
@@ -15,6 +15,7 @@ use std::time::Duration;
 use futures::StreamExt;
 use url::Url;

+use crate::highlight::annotate_hints;
 use crate::html::word_count;
 use crate::images::normalize::{normalize_img_tags, prepare_for_readability};
 use crate::images::refs::collect_image_urls;
@@ -338,7 +339,8 @@ fn readable_page(
    html: &str,
    url: &str,
 ) -> Result<(String, String, Option<String>, Option<String>), ExtractError> {
-    let html = prepare_for_readability(html);
+    // Readability strips classes, and with them code blocks' language hints.
+    let html = prepare_for_readability(&annotate_hints(html));
    let config = dom_smoothie::Config {
        max_elements_to_parse: 60_000,
        ..Default::default()
@@ -447,6 +449,7 @@ fn builder() -> ammonia::Builder<'static> {
        .generic_attributes(HashSet::new())
        .link_rel(None)
        .strip_comments(true);
+    crate::highlight::keep_lang_attr(&mut b);
    b
 }

@@ -454,8 +457,10 @@ fn builder() -> ammonia::Builder<'static> {
 ///
 /// Allowed: `p`, `h1`–`h4`, `ul`/`ol`/`li`, `blockquote`, `pre`, `code`, `em`,
 /// `strong`, `a`, `img`, `figure`, `figcaption`, table basics, `hr`, `br`.
+/// The one attribute kept beyond links and images is a code block's language,
+/// as `<pre data-lang>` (see [`crate::highlight`]).
 pub fn sanitize(html: &str) -> String {
-    builder().clean(html).to_string()
+    builder().clean(&annotate_hints(html)).to_string()
 }

 /// [`sanitize`], additionally rewriting relative `href`/`src` against `base_url`
@@ -464,7 +469,7 @@ pub fn sanitize_with_base(html: &str, base_url: &str) -> String {
    match Url::parse(base_url) {
        Ok(base) => builder()
            .url_relative(ammonia::UrlRelative::RewriteWithBase(base))
-            .clean(html)
+            .clean(&annotate_hints(html))
            .to_string(),
        Err(_) => sanitize(html),
    }
@@ -546,6 +551,26 @@ mod tests {
        format!("<p>{}</p>", "lorem ".repeat(words))
    }

+    #[test]
+    fn sanitize_keeps_code_block_languages_as_data_lang_only() {
+        let dirty = r#"<div class="language-ruby highlighter-rouge"><pre class="highlight"><code>puts 1</code></pre></div>
+            <pre><code class="language-rust" data-x="y">fn main() {}</code></pre>
+            <pre data-lang="&quot; onload=&quot;x">forged</pre>
+            <p data-lang="rust">not a block</p>"#;
+        let clean = sanitize(dirty);
+        assert!(
+            clean.contains(r#"<pre data-lang="ruby"><code>puts 1</code></pre>"#),
+            "{clean}"
+        );
+        assert!(
+            clean.contains(r#"<pre data-lang="rust"><code>fn main() {}</code></pre>"#),
+            "{clean}"
+        );
+        assert!(clean.contains("<pre>forged</pre>"), "{clean}");
+        assert!(clean.contains("<p>not a block</p>"), "{clean}");
+        assert!(!clean.contains("class="));
+    }
+
    #[test]
    fn sanitize_keeps_the_allowlist_and_drops_everything_else() {
        let dirty = r#"
@@ -0,0 +1,743 @@
+//! Syntax highlighting for code blocks in article bodies.
+//!
+//! Two halves, run at different times:
+//!
+//! * [`annotate_hints`] runs on source markup at extraction, before
+//!   readability and the sanitizer strip every `class`. It reads whatever
+//!   language hint the page carries (`language-rust`, Rouge's wrapper `<div>`,
+//!   SyntaxHighlighter's `brush: py`, `data-lang`, …) and records it as one
+//!   normalized `data-lang` on the `<pre>`, which both of them keep.
+//! * [`highlight_blocks`] runs at render time, on sanitized markup, for the web
+//!   article page and both EPUB editions. Blocks with a hint use it; blocks
+//!   without one are guessed from their content ([`guess_language`]), and
+//!   anything not confidently code is left exactly as it was.
+//!
+//! Tokens come out as flat `<span class="hl-…">` elements, one class each, so
+//! the X4 stylesheet (no descendant selectors) can style them too. Colours are
+//! the stylesheets' business: the web theme is in `src/web/tailwind.css`, the
+//! monochrome e-ink themes in `src/epub/templates/style*.css`.
+
+use std::borrow::Cow;
+use std::sync::{Arc, LazyLock};
+
+use arborium::{Config, GrammarStore, Highlighter, HtmlFormat};
+
+use crate::html::{attr_escape, decode_entities, parse_attrs, tag_end, tag_name};
+
+/// The attribute that carries a block's language from extraction to render.
+pub const LANG_ATTR: &str = "data-lang";
+
+/// The `data-lang` value for a block its source marked as not code (plain
+/// text, program output): never highlighted, never guessed.
+pub const PLAIN: &str = "text";
+
+/// Prefix of every token class, e.g. `hl-keyword`.
+const CLASS_PREFIX: &str = "hl";
+
+/// Hints that mean "this is not source code".
+const PLAIN_HINTS: &[&str] = &[
+    "text",
+    "txt",
+    "plain",
+    "plaintext",
+    "none",
+    "nohighlight",
+    "no-highlight",
+    "output",
+    "console",
+    "terminal",
+    "log",
+];
+
+/// Attributes that name a block's language outright.
+const LANG_ATTRIBUTES: &[&str] = &[
+    "data-lang",
+    "data-language",
+    "data-code-block-lang",
+    "data-code-language",
+];
+
+/// Class prefixes highlighters put in front of a language name.
+const CLASS_PREFIXES: &[&str] = &[
+    "language-",
+    "lang-",
+    "highlight-source-",
+    "highlight-",
+    "source-",
+];
+
+/// Minimum model confidence for a guessed language. Measured on short real
+/// snippets, guesses at or above this were right; below it they were coin flips.
+const MIN_GUESS_SCORE: f32 = 0.5;
+
+/// Unhinted blocks shorter than this are left alone: one-liners are usually a
+/// command or a path, and too short to classify.
+const MIN_GUESS_CHARS: usize = 40;
+
+/// A block that is only plausibly code is weighed against the article's
+/// prevailing language using at most this many of its best candidates…
+const MAX_CANDIDATES: usize = 3;
+
+/// …each scoring at least this much.
+const MIN_CANDIDATE_SCORE: f32 = 0.1;
+
+/// The detector reads at most this much of a block.
+const MAX_GUESS_BYTES: usize = 4096;
+
+/// Compiled grammars, shared across threads; each call gets its own parser.
+static GRAMMARS: LazyLock<Arc<GrammarStore>> = LazyLock::new(|| Arc::new(GrammarStore::new()));
+
+fn new_highlighter() -> Highlighter {
+    Highlighter::with_store_and_config(
+        GRAMMARS.clone(),
+        Config {
+            html_format: HtmlFormat::ClassNamesWithPrefix(CLASS_PREFIX.into()),
+            ..Default::default()
+        },
+    )
+}
+
+/// Whether `name` (a language or one of arborium's aliases) has a grammar.
+fn supported(name: &str) -> bool {
+    GRAMMARS.get(name).is_some()
+}
+
+// ---------------------------------------------------------------------------
+// Hints (extraction time)
+// ---------------------------------------------------------------------------
+
+/// Normalize one hint token (`language-rust`, `py`, `nohighlight`) to the
+/// value stored in `data-lang`: a supported language name or [`PLAIN`].
+///
+/// A bare token (no `language-` style prefix) must be at least two characters,
+/// so stray one-letter classes don't turn into C or R.
+pub fn normalize_hint(token: &str) -> Option<String> {
+    let token = token.trim().trim_matches(';').to_ascii_lowercase();
+    let (name, prefixed) = CLASS_PREFIXES
+        .iter()
+        .find_map(|p| token.strip_prefix(p).map(|rest| (rest, true)))
+        .unwrap_or((token.as_str(), false));
+    if name.is_empty() || (!prefixed && name.len() < 2) {
+        return None;
+    }
+    if PLAIN_HINTS.contains(&name) {
+        return Some(PLAIN.to_string());
+    }
+    let name = canonical_name(name);
+    supported(name).then(|| name.to_string())
+}
+
+/// The name detection uses for the common aliases a hint may carry, so a
+/// `py` block and a guessed `python` block count as the same language.
+fn canonical_name(name: &str) -> &str {
+    match name {
+        "py" | "python3" => "python",
+        "js" | "node" | "jsx" => "javascript",
+        "ts" => "typescript",
+        "sh" | "shell" => "bash",
+        "rs" => "rust",
+        "golang" => "go",
+        "rb" => "ruby",
+        "yml" => "yaml",
+        "c++" | "cxx" | "cc" | "hpp" => "cpp",
+        "cs" | "csharp" | "c#" => "c-sharp",
+        "objective-c" | "objectivec" => "objc",
+        "kt" => "kotlin",
+        "ex" | "exs" => "elixir",
+        "hs" => "haskell",
+        "ps1" | "pwsh" => "powershell",
+        other => other,
+    }
+}
+
+/// The language hint carried by one element's attributes, if any.
+fn hint_from_attrs(attrs: &[(String, String)]) -> Option<String> {
+    for (name, value) in attrs {
+        if LANG_ATTRIBUTES.contains(&name.as_str())
+            && let Some(hint) = normalize_hint(value)
+        {
+            return Some(hint);
+        }
+    }
+    let class = attrs.iter().find(|(name, _)| name == "class")?.1.as_str();
+    // SyntaxHighlighter writes `class="brush: python; gutter: false"`.
+    let tokens: Vec<&str> = class
+        .split(|c: char| c.is_whitespace() || c == ';')
+        .filter(|t| !t.is_empty())
+        .collect();
+    for (i, token) in tokens.iter().enumerate() {
+        let candidate = match token.strip_prefix("brush:") {
+            Some("") => tokens.get(i + 1).copied(),
+            Some(rest) => Some(rest),
+            None if i > 0 && tokens[i - 1] == "brush:" => None,
+            None => Some(*token),
+        };
+        if let Some(hint) = candidate.and_then(normalize_hint) {
+            return Some(hint);
+        }
+    }
+    None
+}
+
+/// Record each `<pre>`'s language hint as `data-lang`, before readability and
+/// the sanitizer strip the classes that carry it.
+///
+/// The hint may sit on the `<pre>`, on the `<code>` right inside it, or on an
+/// enclosing `<div>` (Jekyll's Rouge, GitHub's `highlight-source-*`). Markup is
+/// otherwise returned byte-identical.
+pub fn annotate_hints(html: &str) -> String {
+    let mut out = String::with_capacity(html.len() + 64);
+    let mut cursor = 0usize;
+    // Hint of every open `<div>`, innermost last.
+    let mut divs: Vec<Option<String>> = Vec::new();
+    while let Some(rel) = html[cursor..].find('<') {
+        let start = cursor + rel;
+        out.push_str(&html[cursor..start]);
+        let Some(end) = tag_end(html, start) else {
+            out.push_str(&html[start..]);
+            return out;
+        };
+        let raw = &html[start..end];
+        cursor = end;
+        let inner = raw.trim_start_matches('<').trim_end_matches('>');
+        let name = tag_name(inner);
+        if inner.starts_with('/') {
+            if name == "div" {
+                divs.pop();
+            }
+            out.push_str(raw);
+            continue;
+        }
+        match name.as_str() {
+            "div" => {
+                if !inner.trim_end().ends_with('/') {
+                    divs.push(hint_from_attrs(&parse_attrs(inner)));
+                }
+                out.push_str(raw);
+            }
+            "pre" => {
+                let attrs = parse_attrs(inner.trim_end_matches('/'));
+                let hint = hint_from_attrs(&attrs)
+                    .or_else(|| first_code_hint(html, end))
+                    .or_else(|| divs.iter().rev().find_map(Clone::clone));
+                match hint {
+                    Some(hint) => out.push_str(&pre_tag(&attrs, &hint)),
+                    None => out.push_str(raw),
+                }
+            }
+            _ => out.push_str(raw),
+        }
+    }
+    out.push_str(&html[cursor..]);
+    out
+}
+
+/// The hint on a `<code>` that opens right after a `<pre>` ending at `after`.
+fn first_code_hint(html: &str, after: usize) -> Option<String> {
+    let rest = &html[after..];
+    let start = after + (rest.len() - rest.trim_start().len());
+    if !html[start..].starts_with('<') {
+        return None;
+    }
+    let end = tag_end(html, start)?;
+    let inner = html[start..end]
+        .trim_start_matches('<')
+        .trim_end_matches('>');
+    (tag_name(inner) == "code").then(|| hint_from_attrs(&parse_attrs(inner)))?
+}
+
+/// Rebuild a `<pre>` tag with `data-lang` set to `hint`.
+fn pre_tag(attrs: &[(String, String)], hint: &str) -> String {
+    let mut tag = String::from("<pre");
+    for (name, value) in attrs {
+        if LANG_ATTRIBUTES.contains(&name.as_str()) {
+            continue;
+        }
+        tag.push_str(&format!(" {name}=\"{}\"", attr_escape(value)));
+    }
+    tag.push_str(&format!(" {LANG_ATTR}=\"{}\">", attr_escape(hint)));
+    tag
+}
+
+/// Sanitizer filter for `data-lang`: keep it only if it is a value
+/// [`annotate_hints`] could have written.
+pub fn filter_lang_attr(value: &str) -> Option<String> {
+    normalize_hint(value).filter(|hint| hint == &value.to_ascii_lowercase())
+}
+
+/// Let an ammonia builder keep a valid `data-lang` on `<pre>` (and nothing else
+/// it did not already allow).
+pub fn keep_lang_attr(builder: &mut ammonia::Builder<'_>) {
+    builder
+        .add_tag_attributes("pre", &[LANG_ATTR])
+        .attribute_filter(|element, attribute, value| {
+            if element == "pre" && attribute == LANG_ATTR {
+                filter_lang_attr(value).map(Cow::Owned)
+            } else {
+                Some(Cow::Borrowed(value))
+            }
+        });
+}
+
+/// `ammonia::clean` that keeps block languages, then [`highlight_blocks`]:
+/// the render-time entry point for article bodies.
+pub fn clean_and_highlight(html: &str) -> String {
+    let mut builder = ammonia::Builder::default();
+    keep_lang_attr(&mut builder);
+    highlight_blocks(&builder.clean(html).to_string())
+}
+
+// ---------------------------------------------------------------------------
+// Detection
+// ---------------------------------------------------------------------------
+
+/// What an unhinted block's content says about its language.
+#[derive(Debug, Clone, PartialEq)]
+enum Detected {
+    /// Confidently this language.
+    Sure(&'static str),
+    /// Plausibly one of these, best first: taken only when the rest of the
+    /// article is in one of them (see [`highlight_blocks`]).
+    Maybe(Vec<&'static str>),
+    /// Not code, or too little of it to tell.
+    Unknown,
+}
+
+/// Best guess at the language of an unhinted block, or `None` when it is not
+/// confidently code. A wrong colour scheme is worse than none.
+pub fn guess_language(code: &str) -> Option<&'static str> {
+    match detect(code) {
+        Detected::Sure(language) => Some(language),
+        _ => None,
+    }
+}
+
+fn detect(code: &str) -> Detected {
+    let text = code.trim();
+    // Parsing is proof, at any length.
+    if (text.starts_with('{') || text.starts_with('['))
+        && serde_json::from_str::<serde_json::Value>(text).is_ok()
+    {
+        return Detected::Sure("json");
+    }
+    if text.chars().count() < MIN_GUESS_CHARS && !text.starts_with("#!") {
+        return Detected::Unknown;
+    }
+    if let Some(language) = first_line_language(text) {
+        return Detected::Sure(language);
+    }
+    // A shell session is prompts interleaved with output; neither grammar fits.
+    if text.starts_with("$ ") || text.starts_with("> ") || text.starts_with("% ") {
+        return Detected::Unknown;
+    }
+    let sample = crate::html::truncate_utf8(text, MAX_GUESS_BYTES);
+    let detection = betlang::detect(sample);
+    let mut ranked = detection.top_languages().take(MAX_CANDIDATES);
+    let Some((score, top)) = ranked.next() else {
+        return Detected::Unknown;
+    };
+    // Prose, logs and program output all come out as Markdown.
+    let Some(top) = betlang_language(top) else {
+        return Detected::Unknown;
+    };
+    if score >= MIN_GUESS_SCORE {
+        return Detected::Sure(top);
+    }
+    let mut candidates = vec![top];
+    candidates.extend(
+        ranked
+            .filter(|(score, _)| *score >= MIN_CANDIDATE_SCORE)
+            .filter_map(|(_, language)| betlang_language(language)),
+    );
+    Detected::Maybe(candidates)
+}
+
+/// The grammar for a betlang label, if we have one.
+fn betlang_language(language: betlang::Language) -> Option<&'static str> {
+    let name = match language.slug() {
+        "markdown" => return None,
+        "cs" => "c-sharp",
+        "objectivec" => "objc",
+        "lisp" => "commonlisp",
+        "shell" => "bash",
+        "gemfile" | "gemspec" => "ruby",
+        "gradle" => "groovy",
+        other => other,
+    };
+    supported(name).then_some(name)
+}
+
+/// Languages a block announces on its first line: shebangs and XML-ish preludes.
+fn first_line_language(text: &str) -> Option<&'static str> {
+    let first = text.lines().next()?.trim().to_ascii_lowercase();
+    if let Some(shebang) = first.strip_prefix("#!") {
+        let interpreter = shebang
+            .split_whitespace()
+            .flat_map(|word| word.rsplit('/').next())
+            .find(|word| *word != "env" && !word.starts_with('-'))?;
+        let name = match interpreter.trim_end_matches(|c: char| c.is_ascii_digit() || c == '.') {
+            "sh" | "bash" | "dash" | "ksh" => "bash",
+            "zsh" => "zsh",
+            "fish" => "fish",
+            "python" => "python",
+            "node" | "deno" | "bun" => "javascript",
+            "ruby" => "ruby",
+            "perl" => "perl",
+            "php" => "php",
+            "lua" => "lua",
+            _ => return None,
+        };
+        return supported(name).then_some(name);
+    }
+    if first.starts_with("<?php") {
+        return Some("php");
+    }
+    if first.starts_with("<?xml") {
+        return Some("xml");
+    }
+    // Pages and the tags posts most often quote on their own.
+    if ["<!doctype html", "<html", "<script", "<style", "<template"]
+        .iter()
+        .any(|prefix| first.starts_with(prefix))
+    {
+        return Some("html");
+    }
+    None
+}
+
+// ---------------------------------------------------------------------------
+// Rendering
+// ---------------------------------------------------------------------------
+
+/// One `<pre>` block found by [`highlight_blocks`].
+struct Block {
+    /// Byte range of the opening tag, and where `</pre>` starts.
+    start: usize,
+    open_end: usize,
+    close: usize,
+    attrs: Vec<(String, String)>,
+    hint: Option<String>,
+    code: Option<String>,
+    detected: Detected,
+}
+
+/// Highlight every `<pre>` block in sanitized markup.
+///
+/// A block's language is its `data-lang`, else what its content confidently
+/// says ([`guess_language`]). A block whose content is only plausibly code
+/// takes the article's prevailing language when that is one of its
+/// candidates, so a post in Go does not alternate between highlighted and
+/// plain listings. A highlighted block becomes `<pre><code>…spans…</code></pre>`;
+/// any other block is copied through untouched apart from losing `data-lang`,
+/// which is only for this step.
+pub fn highlight_blocks(html: &str) -> String {
+    if !html.contains("<pre") {
+        return html.to_string();
+    }
+    let blocks = find_blocks(html);
+    let prevailing = prevailing_language(&blocks);
+    let mut highlighter: Option<Highlighter> = None;
+    let mut out = String::with_capacity(html.len() * 2);
+    let mut cursor = 0usize;
+    for block in &blocks {
+        out.push_str(&html[cursor..block.start]);
+        let language = match (block.hint.as_deref(), &block.detected) {
+            (Some(PLAIN), _) => None,
+            (Some(hint), _) => Some(hint),
+            (None, Detected::Sure(language)) => Some(*language),
+            (None, Detected::Maybe(candidates)) => {
+                prevailing.filter(|language| candidates.contains(language))
+            }
+            (None, Detected::Unknown) => None,
+        };
+        let highlighted = match (language, &block.code) {
+            (Some(language), Some(code)) => highlighter
+                .get_or_insert_with(new_highlighter)
+                .highlight(language, code)
+                .ok()
+                .filter(|spans| spans.contains("<span")),
+            _ => None,
+        };
+        match highlighted {
+            Some(spans) => {
+                out.push_str("<pre><code>");
+                out.push_str(&spans);
+                out.push_str("</code></pre>");
+            }
+            None => {
+                out.push_str(&pre_without_lang(
+                    &block.attrs,
+                    block.hint.is_some(),
+                    &html[block.start..block.open_end],
+                ));
+                out.push_str(&html[block.open_end..block.close]);
+                out.push_str("</pre>");
+            }
+        }
+        cursor = block.close + "</pre>".len();
+    }
+    out.push_str(&html[cursor..]);
+    out
+}
+
+/// Every complete `<pre>` block, in order, with its hint and detection.
+fn find_blocks(html: &str) -> Vec<Block> {
+    let mut blocks = Vec::new();
+    let mut cursor = 0usize;
+    while let Some(rel) = html[cursor..].find("<pre") {
+        let start = cursor + rel;
+        let Some(open_end) = tag_end(html, start) else {
+            break;
+        };
+        let inner = html[start..open_end]
+            .trim_start_matches('<')
+            .trim_end_matches('>');
+        if tag_name(inner) != "pre" {
+            cursor = open_end;
+            continue;
+        }
+        let Some(close_rel) = html[open_end..].find("</pre>") else {
+            break;
+        };
+        let close = open_end + close_rel;
+        let attrs = parse_attrs(inner);
+        let hint = attrs
+            .iter()
+            .find(|(name, _)| name == LANG_ATTR)
+            .map(|(_, value)| value.clone());
+        let code = block_text(&html[open_end..close]);
+        let detected = match (&hint, &code) {
+            (None, Some(code)) => detect(code),
+            _ => Detected::Unknown,
+        };
+        blocks.push(Block {
+            start,
+            open_end,
+            close,
+            attrs,
+            hint,
+            code,
+            detected,
+        });
+        cursor = close + "</pre>".len();
+    }
+    blocks
+}
+
+/// The language most of an article's hinted and confidently detected blocks
+/// share, earliest first on a tie.
+fn prevailing_language(blocks: &[Block]) -> Option<&str> {
+    let mut counts: Vec<(&str, usize)> = Vec::new();
+    for block in blocks {
+        let language = match (block.hint.as_deref(), &block.detected) {
+            (Some(PLAIN), _) => continue,
+            (Some(hint), _) => hint,
+            (None, Detected::Sure(language)) => language,
+            _ => continue,
+        };
+        match counts.iter_mut().find(|(name, _)| *name == language) {
+            Some((_, count)) => *count += 1,
+            None => counts.push((language, 1)),
+        }
+    }
+    counts
+        .iter()
+        .rev()
+        .max_by_key(|(_, count)| *count)
+        .map(|(language, _)| *language)
+}
+
+/// The `<pre>` opening tag minus `data-lang`, or `raw` when it had none.
+fn pre_without_lang(attrs: &[(String, String)], had_lang: bool, raw: &str) -> String {
+    if !had_lang {
+        return raw.to_string();
+    }
+    let mut tag = String::from("<pre");
+    for (name, value) in attrs.iter().filter(|(name, _)| name != LANG_ATTR) {
+        tag.push_str(&format!(" {name}=\"{}\"", attr_escape(value)));
+    }
+    tag.push('>');
+    tag
+}
+
+/// The source text of a `<pre>` body: an optional wrapping `<code>` removed,
+/// `<br>` as newlines, inline markup dropped, entities decoded, and the one
+/// leading newline HTML ignores stripped.
+///
+/// `None` when the body holds block markup (a table, a list) — that is a
+/// layout, not a listing, and is left alone.
+fn block_text(body: &str) -> Option<String> {
+    let mut text = String::with_capacity(body.len());
+    let mut cursor = 0usize;
+    while let Some(rel) = body[cursor..].find('<') {
+        let start = cursor + rel;
+        text.push_str(&body[cursor..start]);
+        let end = tag_end(body, start)?;
+        let inner = body[start..end]
+            .trim_start_matches('<')
+            .trim_end_matches('>');
+        match tag_name(inner).as_str() {
+            "br" => text.push('\n'),
+            "code" | "span" | "em" | "strong" | "a" | "b" | "i" | "u" | "s" | "mark" | "kbd"
+            | "samp" | "var" | "sub" | "sup" | "small" => {}
+            _ => return None,
+        }
+        cursor = end;
+    }
+    text.push_str(&body[cursor..]);
+    let text = decode_entities(&text);
+    let text = text
+        .strip_prefix("\r\n")
+        .or_else(|| text.strip_prefix('\n'))
+        .unwrap_or(&text);
+    let text = text.trim_end_matches(['\n', '\r']);
+    (!text.trim().is_empty()).then(|| text.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn normalizes_prefixed_bare_and_plain_hints() {
+        assert_eq!(normalize_hint("language-rust").as_deref(), Some("rust"));
+        assert_eq!(normalize_hint("lang-py").as_deref(), Some("python"));
+        assert_eq!(normalize_hint("highlight-source-go").as_deref(), Some("go"));
+        assert_eq!(normalize_hint("Python").as_deref(), Some("python"));
+        assert_eq!(normalize_hint("language-text").as_deref(), Some(PLAIN));
+        assert_eq!(normalize_hint("nohighlight").as_deref(), Some(PLAIN));
+        assert_eq!(normalize_hint("language-c").as_deref(), Some("c"));
+        // Bare one-letter classes and framework classes are not hints.
+        assert_eq!(normalize_hint("c"), None);
+        assert_eq!(normalize_hint("highlight"), None);
+        assert_eq!(normalize_hint("chroma"), None);
+        assert_eq!(normalize_hint("language-klingon"), None);
+    }
+
+    #[test]
+    fn annotates_hints_from_pre_code_and_wrapper_divs() {
+        assert_eq!(
+            annotate_hints(r#"<pre class="chroma"><code class="language-go">x</code></pre>"#),
+            r#"<pre class="chroma" data-lang="go"><code class="language-go">x</code></pre>"#
+        );
+        assert_eq!(
+            annotate_hints(r#"<pre class="brush: py; gutter: false">x</pre>"#),
+            r#"<pre class="brush: py; gutter: false" data-lang="python">x</pre>"#
+        );
+        // Jekyll/Rouge: the hint is on a wrapper two levels up.
+        assert_eq!(
+            annotate_hints(
+                r#"<div class="language-ruby highlighter-rouge"><div class="highlight"><pre class="highlight"><code>x</code></pre></div></div><pre>y</pre>"#
+            ),
+            r#"<div class="language-ruby highlighter-rouge"><div class="highlight"><pre class="highlight" data-lang="ruby"><code>x</code></pre></div></div><pre>y</pre>"#
+        );
+        assert_eq!(
+            annotate_hints(r#"<pre data-code-block-lang="JavaScript">x</pre>"#),
+            r#"<pre data-lang="javascript">x</pre>"#
+        );
+        let plain = "<p>a</p><pre><code>no hint</code></pre>";
+        assert_eq!(annotate_hints(plain), plain);
+    }
+
+    #[test]
+    fn the_sanitizer_filter_only_keeps_normalized_values() {
+        assert_eq!(filter_lang_attr("rust").as_deref(), Some("rust"));
+        assert_eq!(filter_lang_attr("text").as_deref(), Some(PLAIN));
+        assert_eq!(filter_lang_attr("language-rust"), None);
+        // Hints are stored canonical, so an alias is not a stored value.
+        assert_eq!(filter_lang_attr("py"), None);
+        assert_eq!(filter_lang_attr("\" onload=\"x"), None);
+    }
+
+    #[test]
+    fn highlights_hinted_blocks_with_flat_prefixed_spans() {
+        let out = highlight_blocks(
+            "<p>a</p><pre data-lang=\"rust\"><code>fn main() {\n    let s = \"&lt;&amp;&gt;\";\n}</code></pre><p>b</p>",
+        );
+        assert!(out.starts_with("<p>a</p><pre><code><span class=\"hl-keyword\">fn</span>"));
+        assert!(out.contains("<span class=\"hl-string\">&quot;&lt;&amp;&gt;&quot;</span>"));
+        assert!(out.ends_with("</code></pre><p>b</p>"));
+        assert!(!out.contains("data-lang"));
+    }
+
+    #[test]
+    fn br_line_breaks_and_inline_markup_become_plain_source() {
+        let out = highlight_blocks(
+            "<pre data-lang=\"python\"><code>def f():<br>    <em>return</em> 1</code></pre>",
+        );
+        assert!(out.contains("<span class=\"hl-keyword\">def</span>"));
+        assert!(out.contains("\n    <span class=\"hl-keyword\">return</span>"));
+        assert!(!out.contains("<em>"));
+    }
+
+    #[test]
+    fn plain_and_unrecognized_blocks_are_left_alone() {
+        assert_eq!(
+            highlight_blocks("<pre data-lang=\"text\"><code>def f(): return 1</code></pre>"),
+            "<pre><code>def f(): return 1</code></pre>"
+        );
+        let short = "<pre><code>cargo build</code></pre>";
+        assert_eq!(highlight_blocks(short), short);
+        let prose = "<pre>Dear reader, this is a poem set in a preformatted block\nbecause the author liked the look of it.</pre>";
+        assert_eq!(highlight_blocks(prose), prose);
+        let session = "<pre><code>$ cargo build --release\n   Compiling foo v0.1.0\n    Finished release</code></pre>";
+        assert_eq!(highlight_blocks(session), session);
+    }
+
+    #[test]
+    fn guesses_unhinted_code_by_content() {
+        assert_eq!(
+            guess_language(
+                "import os\n\ndef main():\n    print(os.getcwd())\n\nif __name__ == '__main__':\n    main()\n"
+            ),
+            Some("python")
+        );
+        assert_eq!(
+            guess_language(
+                "SELECT id, name FROM users WHERE created_at > NOW() - INTERVAL '1 day' ORDER BY id;"
+            ),
+            Some("sql")
+        );
+        assert_eq!(
+            guess_language("#!/usr/bin/env bash\nset -euo pipefail"),
+            Some("bash")
+        );
+        assert_eq!(
+            guess_language("{\"a\": [1, 2, 3], \"b\": {\"c\": null}}"),
+            Some("json")
+        );
+        let out = highlight_blocks(
+            "<pre><code>#include &lt;stdio.h&gt;\n\nint main(void) {\n    printf(\"hello\\n\");\n    return 0;\n}</code></pre>",
+        );
+        assert!(out.contains("hl-"), "{out}");
+    }
+
+    #[test]
+    fn an_uncertain_block_takes_the_articles_prevailing_language() {
+        // Both from go.dev/blog/range-functions, which marks no languages.
+        let sure = "<pre><code>// Add adds an element to a set.\nfunc (s *Set[E]) Add(v E) {\n    s.m[v] = struct{}{}\n}\n\n// Contains reports whether an element is in a set.\nfunc (s *Set[E]) Contains(v E) bool {\n    _, ok := s.m[v]\n    return ok\n}\n</code></pre>";
+        let unsure = "<pre><code>func (s *Set[E]) Push(f func(E) bool) {\n    for v := range s.m {\n        if !f(v) {\n            return\n        }\n    }\n}\n</code></pre>";
+        let text = |pre: &str| block_text(&pre[5..pre.len() - 6]).unwrap();
+        assert_eq!(guess_language(&text(sure)), Some("go"));
+        assert_eq!(guess_language(&text(unsure)), None);
+        assert!(matches!(detect(&text(unsure)), Detected::Maybe(c) if c.contains(&"go")));
+
+        let alone = highlight_blocks(unsure);
+        assert_eq!(alone, unsure);
+        let together = highlight_blocks(&format!("{sure}<p>and</p>{unsure}"));
+        assert_eq!(
+            together
+                .matches("<span class=\"hl-keyword\">func</span>")
+                .count(),
+            4
+        );
+    }
+
+    #[test]
+    fn quoted_style_and_script_tags_are_html() {
+        assert_eq!(
+            guess_language("<style>\n* {\n  box-sizing: border-box;\n}\n</style>"),
+            Some("html")
+        );
+    }
+}
@@ -32,6 +32,8 @@ pub const EXITED_BEFORE_START: &str = "unit exited before the job started; see t
 pub enum Job {
    /// `generate` (today) or `generate-YYYY-MM-DD`.
    Generate { date: Option<Date> },
+    /// `rebuild-YYYY-MM-DD` → `rebuild --date`.
+    Rebuild { date: Date },
    /// `dry-run` → `generate --dry-run`.
    DryRun,
    /// `profile-rebuild` → `profile rebuild`.
@@ -70,8 +72,9 @@ impl Job {
                .all(|byte| byte.is_ascii_lowercase() || byte.is_ascii_digit() || byte == b'-')
    }

-    /// Parse a catalogue name or the dated `generate-YYYY-MM-DD` form; anything
-    /// else (including `../x`, uppercase, unknown names) is `None`.
+    /// Parse a catalogue name or a dated `generate-YYYY-MM-DD` or
+    /// `rebuild-YYYY-MM-DD` form; anything else (including `../x`, uppercase,
+    /// unknown names) is `None`.
    pub fn parse(name: &str) -> Option<Job> {
        if !Self::valid_name(name) {
            return None;
@@ -86,10 +89,17 @@ impl Job {
            "import-ratings" => Some(Job::ImportRatings),
            "interests-categorize" => Some(Job::InterestsCategorize),
            _ => {
-                let date = name.strip_prefix("generate-")?;
+                let (rebuild, date) = match name.strip_prefix("generate-") {
+                    Some(date) => (false, date),
+                    None => (true, name.strip_prefix("rebuild-")?),
+                };
                // Exactly `YYYY-MM-DD`; the round trip rejects `2026-9-3`.
                let parsed: Date = date.parse().ok()?;
-                (parsed.to_string() == date).then_some(Job::Generate { date: Some(parsed) })
+                (parsed.to_string() == date).then_some(if rebuild {
+                    Job::Rebuild { date: parsed }
+                } else {
+                    Job::Generate { date: Some(parsed) }
+                })
            }
        }
    }
@@ -98,6 +108,7 @@ impl Job {
        match self {
            Job::Generate { date: None } => "generate".into(),
            Job::Generate { date: Some(date) } => format!("generate-{date}"),
+            Job::Rebuild { date } => format!("rebuild-{date}"),
            Job::DryRun => "dry-run".into(),
            Job::ProfileRebuild => "profile-rebuild".into(),
            Job::FeaturesBackfill => "features-backfill".into(),
@@ -121,6 +132,9 @@ impl Job {
            Job::Generate { date: Some(_) } => {
                "Build and publish the issue of a given date, republishing it if it exists."
            }
+            Job::Rebuild { .. } => {
+                "Re-render and republish a published issue's EPUBs from its stored content, without curating again."
+            }
            Job::DryRun => "Run the whole pipeline but publish nothing and record no issue.",
            Job::ProfileRebuild => {
                "Regenerate the learned taste adjustments from ratings with the editor model."
@@ -144,6 +158,7 @@ impl Job {
    pub fn takes_lock(&self) -> Option<&'static str> {
        match self {
            Job::Generate { .. } | Job::DryRun => Some("generate"),
+            Job::Rebuild { .. } => Some("rebuild"),
            Job::ProfileRebuild => Some("profile rebuild"),
            Job::FeaturesBackfill => Some("features backfill"),
            Job::BackfillSocial => Some("backfill-social"),
@@ -151,9 +166,9 @@ impl Job {
        }
    }

-    /// Needs a confirmation dialog: `generate` republishes an issue.
+    /// Needs a confirmation dialog: `generate` and `rebuild` republish an issue.
    pub fn dangerous(&self) -> bool {
-        matches!(self, Job::Generate { .. })
+        matches!(self, Job::Generate { .. } | Job::Rebuild { .. })
    }
 }

@@ -481,6 +496,24 @@ mod tests {
        assert!(!Job::parse("dry-run").unwrap().dangerous());
    }

+    #[test]
+    fn parse_accepts_the_dated_rebuild_form() {
+        let job = Job::parse("rebuild-2026-10-01").unwrap();
+        assert_eq!(
+            job,
+            Job::Rebuild {
+                date: "2026-10-01".parse().unwrap()
+            }
+        );
+        assert_eq!(job.name(), "rebuild-2026-10-01");
+        assert_eq!(job.unit(), "daily-epub-job@rebuild-2026-10-01.service");
+        assert_eq!(job.takes_lock(), Some("rebuild"));
+        assert!(job.dangerous());
+        for bad in ["rebuild", "rebuild-", "rebuild-2026-10-1", "rebuild-today"] {
+            assert_eq!(Job::parse(bad), None, "{bad}");
+        }
+    }
+
    #[test]
    fn parse_rejects_traversal_uppercase_and_unknown_names() {
        for name in [
@@ -22,6 +22,7 @@ pub mod dedupe;
 pub mod discovery;
 pub mod epub;
 pub mod extract;
+pub mod highlight;
 pub mod html;
 pub mod http;
 pub mod images;
@@ -34,6 +35,7 @@ pub mod miniflux;
 pub mod pipeline;
 pub mod publish;
 pub mod rate;
+pub mod related;
 pub mod report;
 pub mod server;
 pub mod social;
@@ -36,6 +36,8 @@ struct Cli {
 enum Command {
    /// Build (and publish) one issue.
    Generate(GenerateArgs),
+    /// Rebuild and republish a published issue's EPUBs from its stored content.
+    Rebuild(RebuildArgs),
    /// Run the rating endpoints, the OPDS catalog and downloads.
    Serve,
    /// Taste-profile maintenance.
@@ -159,6 +161,13 @@ enum ConfigCommand {
    Check,
 }

+#[derive(Debug, clap::Args)]
+struct RebuildArgs {
+    /// Date of the published issue to rebuild.
+    #[arg(long, value_name = "YYYY-MM-DD")]
+    date: jiff::civil::Date,
+}
+
 #[derive(Debug, clap::Args)]
 struct GenerateArgs {
    /// Issue date in the configured timezone (defaults to today).
@@ -330,6 +339,15 @@ enum FeaturesCommand {
    Backfill(BackfillArgs),
    /// Drop stale embeddings, old candidate telemetry and old assessments per the retention config.
    Prune,
+    /// Recompute the related articles under each issue's web articles.
+    Related(RelatedArgs),
+}
+
+#[derive(Debug, clap::Args)]
+struct RelatedArgs {
+    /// Only this issue (YYYY-MM-DD); every issue when omitted.
+    #[arg(long)]
+    date: Option<jiff::civil::Date>,
 }

 #[derive(Debug, clap::Args)]
@@ -382,6 +400,17 @@ async fn main() -> Result<()> {
            let outcome = pipeline::generate(&config, &db, &GenerateOptions::from(&args)).await?;
            print_outcome(&outcome);
        }
+        Command::Rebuild(args) => {
+            // No migration: this only re-renders what an existing schema holds.
+            let db = Db::open(&config.database_path).await?;
+            let published = pipeline::rebuild(&config, &db, args.date).await?;
+            for artifact in &published.epubs {
+                println!("{:?}: {}", artifact.edition, artifact.path.display());
+            }
+            if let Some(xtc) = &published.xtc {
+                println!("XTC: {}", xtc.display());
+            }
+        }
        Command::Serve => {
            let db = Db::open_and_migrate(&config.database_path).await?;
            let config_path = Config::resolve_path(cli.config.as_deref());
@@ -451,6 +480,14 @@ async fn main() -> Result<()> {
                    }
                    .description()
                );
+                eprintln!(
+                    "  {:<20} {}",
+                    "rebuild-YYYY-MM-DD",
+                    jobs::Job::Rebuild {
+                        date: jiff::civil::Date::default()
+                    }
+                    .description()
+                );
                std::process::exit(2);
            };
            let db = Db::open_and_migrate(&config.database_path).await?;
@@ -461,12 +498,13 @@ async fn main() -> Result<()> {
 }

 /// The commands that write the database and provider budgets and so hold the
-/// run lock (§5): `generate`, `profile rebuild`, `features backfill`,
+/// run lock (§5): `generate`, `rebuild`, `profile rebuild`, `features backfill`,
 /// `backfill-social`, `interests backfill`, and a `job run` of any of them.
 /// Everything else is read-only or its own writer.
 fn lock_holder(command: &Command) -> Option<&'static str> {
    match command {
        Command::Generate(_) => Some("generate"),
+        Command::Rebuild(_) => Some("rebuild"),
        // Writes the same tables the discovery stage of a run writes.
        Command::Feeds(FeedsCommand::Discover(_)) => Some("feeds discover"),
        Command::Profile(ProfileCommand::Rebuild) => Some("profile rebuild"),
@@ -483,6 +521,7 @@ fn lock_holder(command: &Command) -> Option<&'static str> {
        | Command::Explain(_)
        | Command::Stats(_)
        | Command::Features(FeaturesCommand::Prune)
+        | Command::Features(FeaturesCommand::Related(_))
        | Command::Db(_)
        | Command::Config(_)
        | Command::Users(_)
@@ -1033,7 +1072,7 @@ async fn cmd_explain(db: &Db, args: ExplainArgs) -> Result<()> {
    Ok(())
 }

-/// `features backfill` / `features prune`; returns the final summary line
+/// `features backfill` / `features prune` / `features related`; returns the final summary line
 /// (progress lines are printed as they happen).
 async fn cmd_features(config: &Config, db: &Db, command: FeaturesCommand) -> Result<String> {
    match command {
@@ -1091,13 +1130,25 @@ async fn cmd_features(config: &Config, db: &Db, command: FeaturesCommand) -> Res
                jiff::Timestamp::now(),
            )
            .await?;
+            let embeddings = if ranking.embedding_retention_days <= 0 {
+                "kept every embedding (retention 0)".to_string()
+            } else {
+                format!(
+                    "pruned {} embeddings older than {} days",
+                    pruned.embeddings, ranking.embedding_retention_days
+                )
+            };
            Ok(format!(
-                "pruned {} embeddings older than {} days, {} candidate rows and {} assessments older than {} days",
-                pruned.embeddings,
-                ranking.embedding_retention_days,
-                pruned.telemetry,
-                pruned.assessments,
-                ranking.telemetry_retention_days
+                "{embeddings}, {} candidate rows and {} assessments older than {} days",
+                pruned.telemetry, pruned.assessments, ranking.telemetry_retention_days
+            ))
+        }
+        FeaturesCommand::Related(args) => {
+            let dates: Vec<_> = args.date.into_iter().collect();
+            let refreshed = daily_epub::related::refresh(db, &config.voyage, &dates).await?;
+            Ok(format!(
+                "stored {} related links across {} issues",
+                refreshed.links, refreshed.issues
            ))
        }
    }
@@ -1161,6 +1212,21 @@ async fn run_job(config: &Config, db: &Db, job: &jobs::Job) -> Result<(String, O
        jobs::Job::Generate { date } => {
            generate_job(config, db, date.map(|date| date.to_string()), false).await
        }
+        jobs::Job::Rebuild { date } => {
+            let published = pipeline::rebuild(config, db, *date).await?;
+            let xtc = if published.xtc.is_some() {
+                " and the XTC"
+            } else {
+                ""
+            };
+            Ok((
+                format!(
+                    "rebuilt the {date} issue: {} EPUBs{xtc}",
+                    published.epubs.len()
+                ),
+                None,
+            ))
+        }
        jobs::Job::DryRun => generate_job(config, db, None, true).await,
        jobs::Job::ProfileRebuild => Ok((cmd_profile_rebuild(config, db).await?, None)),
        jobs::Job::FeaturesBackfill => {
@@ -1450,7 +1516,7 @@ mod tests {
            row.message
                .as_deref()
                .unwrap_or_default()
-                .starts_with("pruned 0 embeddings"),
+                .starts_with("kept every embedding (retention 0)"),
            "{row:?}"
        );
        assert_eq!(row.run_id, None);
@@ -1640,6 +1706,15 @@ mod tests {
                .command,
            Command::Features(FeaturesCommand::Prune)
        ));
+        match Cli::try_parse_from(["daily-epub", "features", "related", "--date", "2026-09-01"])
+            .unwrap()
+            .command
+        {
+            Command::Features(FeaturesCommand::Related(args)) => {
+                assert_eq!(args.date, Some("2026-09-01".parse().unwrap()));
+            }
+            other => panic!("expected features related, got {other:?}"),
+        }
    }

    #[tokio::test]
@@ -268,6 +268,7 @@ pub async fn generate(config: &Config, db: &Db, opts: &GenerateOptions) -> Resul
    db.finish_run(run_id, &report).await?;
    if stages.published.is_some() {
        prune_retention(config, db).await;
+        refresh_related(config, db, date).await;
    }
    // The issue row is written before the report is costed, so stamp the finished
    // report onto it now (the paths are preserved by `COALESCE`, §3.13).
@@ -321,6 +322,15 @@ async fn prune_retention(config: &Config, db: &Db) {
    }
 }

+/// Store the issue's related-article links (best effort: a failure only
+/// leaves the web article pages without them until `features related`).
+async fn refresh_related(config: &Config, db: &Db, date: Date) {
+    match crate::related::refresh(db, &config.voyage, &[date]).await {
+        Ok(refreshed) => tracing::info!(links = refreshed.links, "related articles stored"),
+        Err(error) => tracing::warn!(%error, "related articles failed; continuing"),
+    }
+}
+
 /// What [`run_stages`] hands back; [`generate`] pairs it with the costed report.
 #[derive(Debug)]
 struct StageOutput {
@@ -648,27 +658,19 @@ async fn run_stages(
        .copied()
        .filter(|id| !selected_set.contains(id))
        .collect::<Vec<_>>();
-    // The editor's one-line `why` (§13) lands in `candidate_runs.editor_why` so
-    // `explain` can quote it; heuristic picks leave it NULL.
-    let selected_with_why = lineup
-        .picks
-        .iter()
-        .map(|pick| (pick.article.id, pick.why.as_deref()))
-        .collect::<Vec<_>>();
    set_candidate_stage(
        &mut personalized,
        &not_selected,
        "shortlisted",
        Some("not_selected"),
    );
-    let why = selected_with_why.into_iter().collect::<HashMap<_, _>>();
    for candidate in &mut personalized {
        if selected_set.contains(&candidate.article.id) {
            candidate.stage = "selected".into();
            candidate.excluded_reason = None;
        }
    }
-    record_candidates_with_why(ctx, &personalized, &why)
+    record_candidates(ctx, &personalized)
        .await
        .context("recording selection telemetry")?;
    report.counts.exploration_selected = personalized
@@ -1039,14 +1041,6 @@ async fn prepare_features(
 }

 async fn record_candidates(ctx: &StageContext<'_>, candidates: &[Candidate]) -> Result<()> {
-    record_candidates_with_why(ctx, candidates, &HashMap::new()).await
-}
-
-async fn record_candidates_with_why(
-    ctx: &StageContext<'_>,
-    candidates: &[Candidate],
-    editor_why: &HashMap<ArticleId, Option<&str>>,
-) -> Result<()> {
    for candidate in candidates {
        let json = telemetry::serialize_candidate(candidate);
        let admitted_by = if candidate.admitted_by.is_empty() {
@@ -1067,7 +1061,6 @@ async fn record_candidates_with_why(
                rank_utility: candidate.rank_utility,
                cluster_id: candidate.cluster,
                cluster_rank: candidate.cluster_rank,
-                editor_why: editor_why.get(&candidate.article.id).copied().flatten(),
            },
        )
        .await
@@ -1112,6 +1105,51 @@ async fn persist_articles(db: &Db, articles: &mut [Article]) -> Result<()> {
    Ok(())
 }

+/// Rebuild and republish a published issue's EPUBs (and XTC) from its stored
+/// snapshot, for when rendering changed after the issue went out.
+///
+/// The content is exactly the issue's: the `issues.issue_json` snapshot with
+/// each article's body restored from its row (the snapshot drops bodies).
+/// Unlike the web reader it does not refresh anything else from the live rows,
+/// so social lines and metadata stay as published. Nothing is curated or
+/// fetched except the images, which are downloaded again as in a run.
+pub async fn rebuild(config: &Config, db: &Db, date: Date) -> Result<Published> {
+    let row = db
+        .issue_by_date(date)
+        .await?
+        .with_context(|| format!("no issue for {date}"))?;
+    let raw = row
+        .issue_json
+        .with_context(|| format!("the {date} issue predates issue snapshots"))?;
+    let mut issue: Issue = serde_json::from_str(&raw).context("decoding issues.issue_json")?;
+    let ids: Vec<ArticleId> = issue.lineup.picks.iter().map(|p| p.article.id).collect();
+    let mut articles = db.get_articles(&ids).await?;
+    for pick in &mut issue.lineup.picks {
+        let article = articles
+            .remove(&pick.article.id)
+            .with_context(|| format!("article {} is gone", pick.article.id))?;
+        pick.article.content_html = article.content_html;
+    }
+
+    let (artifacts, _) = epub::build_all(&issue, config, &config.out_dir)
+        .await
+        .context("building the EPUB editions")?;
+    let x4 = artifacts.iter().find(|a| a.edition == Edition::X4);
+    let xtc = match x4 {
+        Some(artifact) if config.xtc.enabled => {
+            Some(epub::x4::convert(&config.xtc, &artifact.path, &config.out_dir).await?)
+        }
+        _ => None,
+    };
+    let published = publish::publish_issue(config, &issue, &artifacts, xtc.as_deref())
+        .await
+        .context("publishing the issue")?;
+    record_issue(db, &issue, &published)
+        .await
+        .context("recording the issue")?;
+    Ok(published)
+}
+
 /// Write the `issues` row and replace `issue_articles` for the date (notes §12).
 async fn record_issue(db: &Db, issue: &Issue, published: &Published) -> Result<()> {
    let path_for = |edition: Edition| {
@@ -1363,6 +1401,91 @@ fn elapsed_ms(since: Timestamp) -> i64 {
 mod tests {
    use super::*;

+    /// Read one entry of a zip archive as text.
+    fn zip_entry(path: &std::path::Path, name: &str) -> String {
+        use std::io::Read;
+        let mut archive = zip::ZipArchive::new(std::fs::File::open(path).unwrap()).unwrap();
+        let mut text = String::new();
+        archive
+            .by_name(name)
+            .unwrap()
+            .read_to_string(&mut text)
+            .unwrap();
+        text
+    }
+
+    #[tokio::test]
+    async fn rebuild_republishes_from_the_snapshot_without_touching_it() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = Db::open_and_migrate(&dir.path().join("db.sqlite"))
+            .await
+            .unwrap();
+        let mut issue = crate::epub::fixtures::issue();
+        for pick in &mut issue.lineup.picks {
+            // No images: the rebuild must not need the network here.
+            pick.article.content_html =
+                "<p>Before.</p><pre data-lang=\"rust\"><code>fn main() {}</code></pre>".into();
+            pick.article.image_count = 0;
+            let article = &pick.article;
+            db.upsert_entry(&crate::types::Entry {
+                id: article.best_entry_id,
+                feed_id: article.feed_id,
+                feed_title: Some(article.feed_title.clone()),
+                category: article.category.clone(),
+                title: article.title.clone(),
+                url: article.url.clone(),
+                canonical_url: Some(article.canonical_url.clone()),
+                author: article.author.clone(),
+                published_at: article.published_at,
+                comments_url: article.comments_url.clone(),
+                raw_content: article.content_html.clone(),
+                fetched_at: article.first_seen,
+            })
+            .await
+            .unwrap();
+            pick.article.id = db.upsert_article(article).await.unwrap();
+        }
+        let mut snapshot = issue.clone();
+        for pick in &mut snapshot.lineup.picks {
+            pick.article.content_html.clear();
+        }
+        let issue_json = serde_json::to_string(&snapshot).unwrap();
+        db.upsert_issue(
+            issue.meta.date,
+            issue.meta.issue_number,
+            issue.meta.generated_at,
+            None,
+            None,
+            None,
+            Some(&issue.editorial.front_page_html),
+            None,
+            Some(&issue_json),
+        )
+        .await
+        .unwrap();
+
+        let mut config = Config {
+            out_dir: dir.path().join("out"),
+            ..Config::default()
+        };
+        config.publish.epub_dir = dir.path().join("epubs");
+        config.publish.xtc_dir = dir.path().join("xtc");
+        config.xtc.enabled = false;
+        let published = rebuild(&config, &db, issue.meta.date).await.unwrap();
+
+        assert_eq!(published.epubs.len(), 2);
+        let row = db.issue_by_date(issue.meta.date).await.unwrap().unwrap();
+        assert_eq!(row.issue_json.as_deref(), Some(issue_json.as_str()));
+        let standard = &published.epubs[0];
+        assert_eq!(
+            row.epub_path.as_deref(),
+            Some(standard.path.to_str().unwrap())
+        );
+        let chapter = zip_entry(&standard.path, "OEBPS/art-1001.xhtml");
+        assert!(chapter.contains("<p>Before.</p>"), "body restored");
+        assert!(chapter.contains("<span class=\"hl-keyword\">fn</span>"));
+    }
+
    #[test]
    fn display_date_matches_the_masthead_format() {
        let date: Date = "2026-08-15".parse().unwrap();
@@ -0,0 +1,446 @@
+//! Related articles under each web issue article.
+//!
+//! For every pick, the nearest embedded articles across the whole archive
+//! (`article_embeddings`, kept forever by default). Finding them is a scan of
+//! every cached vector, so it runs once when an issue is published and once
+//! per issue from `features related`, and the result lives in `issue_related`;
+//! reader pages only read that table.
+
+use std::collections::{HashMap, HashSet};
+
+use anyhow::Result;
+use jiff::civil::Date;
+use sqlx::Row as _;
+
+use crate::config::VoyageConfig;
+use crate::curate::embedding::{decode_blob, dot, load_article_embeddings};
+use crate::db::Db;
+use crate::types::ArticleId;
+
+/// Links shown under each article.
+const PER_ARTICLE: usize = 5;
+/// Below this cosine a neighbour is noise, not a related article (the same
+/// cut the curation prompts use for "closest rated").
+const MIN_COSINE: f64 = 0.55;
+/// Embedding rows decoded per statement, so memory stays flat as the archive grows.
+const SCAN_PAGE: i64 = 1000;
+/// Candidates kept per pick between pages: enough headroom for the
+/// same-story filter at the end to still fill [`PER_ARTICLE`].
+const KEEP: usize = PER_ARTICLE * 4;
+/// Share of title words two articles from one site must have in common to be
+/// one story re-published under a new URL ("…after AI accusations" and
+/// "…after AI allegations").
+const SAME_SITE_TITLE_OVERLAP: f64 = 0.8;
+
+/// What [`refresh`] wrote.
+#[derive(Debug, Default, PartialEq)]
+pub struct Refreshed {
+    pub issues: usize,
+    pub links: usize,
+}
+
+/// Recompute `issue_related` for the given issues (every issue when `dates` is
+/// empty) in one pass over the embedding cache.
+///
+/// Excluded: the pick itself, the rest of its issue, articles that only have a
+/// feed excerpt (their page would be near-empty), and articles that are the
+/// pick's or a closer link's story again (see [`Story::same_as`]).
+pub async fn refresh(db: &Db, voyage: &VoyageConfig, dates: &[Date]) -> Result<Refreshed> {
+    let dates = if dates.is_empty() {
+        sqlx::query_scalar::<_, String>("SELECT date FROM issues ORDER BY date")
+            .fetch_all(db.pool())
+            .await?
+            .into_iter()
+            .filter_map(|raw| raw.parse().ok())
+            .collect()
+    } else {
+        dates.to_vec()
+    };
+
+    // Every pick of every requested issue, with its story key for de-duplication.
+    let mut groups: Vec<Group> = Vec::with_capacity(dates.len());
+    for date in &dates {
+        let rows = sqlx::query(
+            "SELECT ia.article_id, a.title, a.canonical_url FROM issue_articles ia
+             JOIN articles a ON a.id = ia.article_id
+             WHERE ia.issue_date = ? ORDER BY ia.section, ia.position",
+        )
+        .bind(date.to_string())
+        .fetch_all(db.pool())
+        .await?;
+        groups.push(Group {
+            date: *date,
+            members: rows.iter().map(|row| row.get("article_id")).collect(),
+            picks: rows
+                .iter()
+                .map(|row| Target {
+                    article_id: row.get("article_id"),
+                    story: Story::from_row(row),
+                    vector: Vec::new(),
+                    best: Vec::new(),
+                })
+                .collect(),
+        });
+    }
+    let ids: Vec<ArticleId> = groups
+        .iter()
+        .flat_map(|group| group.picks.iter().map(|pick| pick.article_id))
+        .collect();
+    let mut vectors = load_article_embeddings(db, voyage, &ids).await?;
+    for group in &mut groups {
+        // A pick without a cached vector simply gets no related list.
+        group
+            .picks
+            .retain_mut(|pick| match vectors.remove(&pick.article_id) {
+                Some(vector) => {
+                    pick.vector = vector;
+                    true
+                }
+                None => false,
+            });
+    }
+
+    let mut after = i64::MIN;
+    loop {
+        let rows = sqlx::query(
+            "SELECT ae.article_id, ae.embedding, a.title, a.canonical_url
+             FROM article_embeddings ae JOIN articles a ON a.id = ae.article_id
+             WHERE ae.model = ? AND ae.dimension = ? AND a.excerpt_only = 0
+               AND ae.article_id > ?
+             ORDER BY ae.article_id LIMIT ?",
+        )
+        .bind(&voyage.model)
+        .bind(voyage.output_dimension as i64)
+        .bind(after)
+        .bind(SCAN_PAGE)
+        .fetch_all(db.pool())
+        .await?;
+        let Some(last) = rows.last() else { break };
+        after = last.get("article_id");
+        for row in &rows {
+            let candidate: ArticleId = row.get("article_id");
+            let vector = match decode_blob(
+                &row.get::<Vec<u8>, _>("embedding"),
+                voyage.output_dimension,
+            ) {
+                Ok(vector) => vector,
+                Err(error) => {
+                    tracing::warn!(article_id = candidate, %error, "ignoring a malformed embedding");
+                    continue;
+                }
+            };
+            let story = Story::from_row(row);
+            for group in &mut groups {
+                if group.members.contains(&candidate) {
+                    continue;
+                }
+                for pick in &mut group.picks {
+                    let cosine = dot(&pick.vector, &vector)?;
+                    if cosine.is_finite() && cosine >= MIN_COSINE {
+                        pick.best.push((candidate, cosine, story.clone()));
+                    }
+                }
+            }
+        }
+        for group in &mut groups {
+            for pick in &mut group.picks {
+                // Highest cosine first; ties by id so reruns write the same rows.
+                pick.best.sort_by(|left, right| {
+                    right
+                        .1
+                        .total_cmp(&left.1)
+                        .then_with(|| left.0.cmp(&right.0))
+                });
+                pick.best.truncate(KEEP);
+            }
+        }
+    }
+
+    let mut refreshed = Refreshed::default();
+    let mut tx = db.pool().begin().await?;
+    for group in &groups {
+        let date = group.date.to_string();
+        sqlx::query("DELETE FROM issue_related WHERE issue_date = ?")
+            .bind(&date)
+            .execute(&mut *tx)
+            .await?;
+        for pick in &group.picks {
+            let mut seen = vec![&pick.story];
+            let mut chosen = Vec::new();
+            for (id, cosine, story) in &pick.best {
+                if chosen.len() == PER_ARTICLE {
+                    break;
+                }
+                if !seen.iter().any(|earlier| earlier.same_as(story)) {
+                    seen.push(story);
+                    chosen.push((id, cosine));
+                }
+            }
+            for (position, (related_id, cosine)) in chosen.into_iter().enumerate() {
+                sqlx::query(
+                    "INSERT INTO issue_related (issue_date, article_id, position, related_id, cosine)
+                     VALUES (?, ?, ?, ?, ?)",
+                )
+                .bind(&date)
+                .bind(pick.article_id)
+                .bind(position as i64)
+                .bind(related_id)
+                .bind(cosine)
+                .execute(&mut *tx)
+                .await?;
+                refreshed.links += 1;
+            }
+        }
+        refreshed.issues += 1;
+    }
+    tx.commit().await?;
+    Ok(refreshed)
+}
+
+/// The stored related links for one pick, closest first.
+pub async fn for_article(db: &Db, date: Date, article_id: ArticleId) -> Result<Vec<ArticleId>> {
+    Ok(sqlx::query_scalar(
+        "SELECT related_id FROM issue_related
+         WHERE issue_date = ? AND article_id = ? ORDER BY position",
+    )
+    .bind(date.to_string())
+    .bind(article_id)
+    .fetch_all(db.pool())
+    .await?)
+}
+
+/// The most recent issue each of `ids` was published in, for linking a related
+/// article to its issue page rather than the standalone one.
+pub async fn latest_issues(db: &Db, ids: &[ArticleId]) -> Result<HashMap<ArticleId, Date>> {
+    let mut issues = HashMap::new();
+    for id in ids {
+        let date: Option<String> =
+            sqlx::query_scalar("SELECT MAX(issue_date) FROM issue_articles WHERE article_id = ?")
+                .bind(id)
+                .fetch_one(db.pool())
+                .await?;
+        if let Some(date) = date.and_then(|raw| raw.parse().ok()) {
+            issues.insert(*id, date);
+        }
+    }
+    Ok(issues)
+}
+
+struct Group {
+    date: Date,
+    /// Every pick of the issue, embedded or not: none of them is "related".
+    members: HashSet<ArticleId>,
+    picks: Vec<Target>,
+}
+
+struct Target {
+    article_id: ArticleId,
+    story: Story,
+    vector: Vec<f32>,
+    /// (candidate, cosine, story), closest first after each scan page.
+    best: Vec<(ArticleId, f64, Story)>,
+}
+
+/// What decides whether two articles are one story told twice. The ingest
+/// dedupe only merges within one run, so a story re-published on another day
+/// under a new URL reaches the archive as a second article.
+#[derive(Clone, Debug)]
+struct Story {
+    /// Canonical URL host without `www.`.
+    site: String,
+    /// Lowercased title words.
+    words: HashSet<String>,
+}
+
+impl Story {
+    fn from_row(row: &sqlx::sqlite::SqliteRow) -> Self {
+        // Re-canonicalized so legacy rows still wrapped in a Scour redirect
+        // count as the outlet's site, not Scour's.
+        let raw: String = row.get("canonical_url");
+        let site = crate::dedupe::canonical_url(&raw)
+            .and_then(|canonical| url::Url::parse(&canonical).ok())
+            .and_then(|url| {
+                url.host_str()
+                    .map(|host| host.trim_start_matches("www.").to_string())
+            })
+            .unwrap_or_default();
+        let words = row
+            .get::<Option<String>, _>("title")
+            .unwrap_or_default()
+            .split(|c: char| !c.is_alphanumeric())
+            .filter(|word| !word.is_empty())
+            .map(str::to_lowercase)
+            .collect();
+        Self { site, words }
+    }
+
+    /// The same title anywhere (syndication), or mostly the same title on the
+    /// same site (a re-slugged republish).
+    fn same_as(&self, other: &Story) -> bool {
+        if self.words.is_empty() || other.words.is_empty() {
+            return false;
+        }
+        if self.words == other.words {
+            return true;
+        }
+        let shared = self.words.intersection(&other.words).count() as f64;
+        let union = self.words.union(&other.words).count() as f64;
+        !self.site.is_empty()
+            && self.site == other.site
+            && shared / union >= SAME_SITE_TITLE_OVERLAP
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::curate::embedding::encode_blob;
+
+    fn voyage() -> VoyageConfig {
+        VoyageConfig {
+            model: "voyage-4-lite".into(),
+            output_dimension: 2,
+            ..VoyageConfig::default()
+        }
+    }
+
+    async fn harness() -> (tempfile::TempDir, Db) {
+        let dir = tempfile::tempdir().unwrap();
+        let db = Db::open_and_migrate(&dir.path().join("related.db"))
+            .await
+            .unwrap();
+        (dir, db)
+    }
+
+    async fn article(db: &Db, id: ArticleId, title: &str, vector: &[f32], excerpt_only: bool) {
+        sqlx::query(
+            "INSERT INTO articles (id, canonical_url, title, excerpt_only, first_seen)
+             VALUES (?, ?, ?, ?, '2026-08-15T00:00:00Z')",
+        )
+        .bind(id)
+        .bind(format!("https://example.com/{id}"))
+        .bind(title)
+        .bind(excerpt_only)
+        .execute(db.pool())
+        .await
+        .unwrap();
+        let norm = vector.iter().map(|v| v * v).sum::<f32>().sqrt();
+        let unit: Vec<f32> = vector.iter().map(|v| v / norm).collect();
+        sqlx::query(
+            "INSERT INTO article_embeddings
+                 (article_id, model, dimension, input_hash, embedding, created_at)
+             VALUES (?, 'voyage-4-lite', 2, 'h', ?, '2026-08-15T00:00:00Z')",
+        )
+        .bind(id)
+        .bind(encode_blob(&unit).unwrap())
+        .execute(db.pool())
+        .await
+        .unwrap();
+    }
+
+    async fn issue(db: &Db, date: &str, picks: &[ArticleId]) {
+        sqlx::query("INSERT INTO issues (date, issue_number, generated_at) VALUES (?, 1, ?)")
+            .bind(date)
+            .bind("2026-09-01T00:00:00Z")
+            .execute(db.pool())
+            .await
+            .unwrap();
+        for (position, id) in picks.iter().enumerate() {
+            sqlx::query(
+                "INSERT INTO issue_articles (issue_date, article_id, section, position)
+                 VALUES (?, ?, 'Top Stories', ?)",
+            )
+            .bind(date)
+            .bind(id)
+            .bind(position as i64)
+            .execute(db.pool())
+            .await
+            .unwrap();
+        }
+    }
+
+    fn day(raw: &str) -> Date {
+        raw.parse().unwrap()
+    }
+
+    #[tokio::test]
+    async fn links_skip_the_issue_excerpts_duplicates_and_far_articles() {
+        let (_dir, db) = harness().await;
+        article(&db, 1, "Rust borrow checker", &[1.0, 0.0], false).await;
+        article(&db, 2, "Same issue neighbour", &[1.0, 0.01], false).await;
+        article(&db, 3, "Lifetimes explained", &[1.0, 0.1], false).await;
+        article(&db, 4, "Paywalled", &[1.0, 0.05], true).await;
+        article(&db, 5, "Rust Borrow-Checker!", &[1.0, 0.02], false).await;
+        article(&db, 6, "Ownership deep dive", &[1.0, 0.3], false).await;
+        article(&db, 7, "Ownership: deep dive", &[1.0, 0.31], false).await;
+        article(&db, 8, "Gardening", &[0.0, 1.0], false).await;
+        issue(&db, "2026-09-01", &[1, 2]).await;
+
+        let refreshed = refresh(&db, &voyage(), &[day("2026-09-01")]).await.unwrap();
+        let one = for_article(&db, day("2026-09-01"), 1).await.unwrap();
+        assert_eq!(one, vec![3, 6], "closest first, one copy of each story");
+        // 5 only repeats article 1's title, so it is fair game for article 2.
+        let two = for_article(&db, day("2026-09-01"), 2).await.unwrap();
+        assert_eq!(two, vec![5, 3, 6]);
+        assert_eq!(
+            refreshed,
+            Refreshed {
+                issues: 1,
+                links: 5
+            }
+        );
+    }
+
+    #[tokio::test]
+    async fn refreshing_every_issue_replaces_rows_and_links_earlier_picks() {
+        let (_dir, db) = harness().await;
+        article(&db, 1, "One", &[1.0, 0.0], false).await;
+        article(&db, 2, "Two", &[1.0, 0.1], false).await;
+        article(&db, 3, "Three", &[1.0, 0.3], false).await;
+        issue(&db, "2026-09-01", &[1]).await;
+        issue(&db, "2026-09-02", &[2]).await;
+
+        assert_eq!(refresh(&db, &voyage(), &[]).await.unwrap().issues, 2);
+        // A rerun rewrites rather than duplicates.
+        refresh(&db, &voyage(), &[]).await.unwrap();
+        let ids = for_article(&db, day("2026-09-02"), 2).await.unwrap();
+        assert_eq!(ids, vec![1, 3]);
+        let issues = latest_issues(&db, &[1, 3]).await.unwrap();
+        assert_eq!(issues.get(&1), Some(&day("2026-09-01")));
+        assert_eq!(issues.get(&3), None);
+    }
+
+    #[test]
+    fn stories_match_on_identical_titles_or_close_titles_from_one_site() {
+        let story = |site: &str, title: &str| Story {
+            site: site.into(),
+            words: title
+                .split(|c: char| !c.is_alphanumeric())
+                .filter(|word| !word.is_empty())
+                .map(str::to_lowercase)
+                .collect(),
+        };
+        let accusations = story(
+            "the-independent.com",
+            "The bestselling novel pulled from prestigious literary prize after AI accusations",
+        );
+        let allegations = story(
+            "the-independent.com",
+            "The bestselling novel pulled from prestigious literary prize after AI allegations",
+        );
+        let conversation = story(
+            "theconversation.com",
+            "A bestselling novel was pulled from a French literary prize after AI accusations – what next?",
+        );
+        assert!(accusations.same_as(&allegations), "a re-slugged republish");
+        assert!(
+            !accusations.same_as(&conversation),
+            "other outlets' coverage stays"
+        );
+        assert!(
+            story("a.com", "Foo: Bar").same_as(&story("b.com", "foo — bar")),
+            "syndicated copies match across sites"
+        );
+        assert!(!story("a.com", "").same_as(&story("a.com", "")));
+    }
+}
@@ -372,8 +372,6 @@ pub struct Pick {
    /// Order within the section, ascending.
    pub position: i64,
    pub is_lead: bool,
-    /// Editor-written reason, at most 14 words (§13).
-    pub why: Option<String>,
    /// Newspaper-abstract summary from stage C; `None` until editorial runs.
    pub summary: Option<String>,
    pub llm: Option<Deep>,
@@ -472,7 +472,6 @@ pub struct HistoryRow {
    pub utility: String,
    pub rank: String,
    pub cluster: String,
-    pub editor_why: Option<String>,
    pub signals: SignalsView,
 }

@@ -640,8 +639,7 @@ pub async fn assessments(
 pub async fn run_history(db: &Db, article_id: ArticleId) -> Result<Vec<HistoryRow>, sqlx::Error> {
    let rows = sqlx::query(
        "SELECT cr.run_id, r.date, r.status, cr.stage, cr.excluded_reason, cr.admitted_by,
-                cr.signals_json, cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank,
-                cr.editor_why
+                cr.signals_json, cr.utility, cr.rank_utility, cr.cluster_id, cr.cluster_rank
         FROM candidate_runs cr JOIN runs r ON r.id = cr.run_id
         WHERE cr.article_id = ? ORDER BY cr.run_id DESC",
    )
@@ -673,7 +671,6 @@ pub async fn run_history(db: &Db, article_id: ArticleId) -> Result<Vec<HistoryRo
                    (Some(id), None) => id.to_string(),
                    _ => "—".into(),
                },
-                editor_why: row.get("editor_why"),
                signals: SignalsView::from_json(&row.get::<String, _>("signals_json")),
            }
        })
@@ -865,17 +865,8 @@ pub(crate) mod tests {
                Some("[\"triage\",\"interest\"]"),
                88.0,
                1,
-                Some("Why one"),
-            ),
-            (
-                2,
-                "selected",
-                None,
-                Some("[\"blend\"]"),
-                80.0,
-                2,
-                Some("Why two"),
            ),
+            (2, "selected", None, Some("[\"blend\"]"), 80.0, 2),
            (
                3,
                "shortlisted",
@@ -883,7 +874,6 @@ pub(crate) mod tests {
                Some("[\"triage\"]"),
                75.0,
                3,
-                None,
            ),
            (
                4,
@@ -892,10 +882,9 @@ pub(crate) mod tests {
                Some("[\"triage\"]"),
                60.0,
                4,
-                None,
            ),
        ];
-        for (article_id, stage, reason, admitted_by, utility, rank, why) in rows {
+        for (article_id, stage, reason, admitted_by, utility, rank) in rows {
            let json = signals(utility / 10.0, article_id == 2);
            telemetry::write(
                &db,
@@ -910,7 +899,6 @@ pub(crate) mod tests {
                    rank_utility: Some(rank),
                    cluster_id: Some(1),
                    cluster_rank: Some(rank),
-                    editor_why: why,
                },
            )
            .await
@@ -931,7 +919,6 @@ pub(crate) mod tests {
                    rank_utility: None,
                    cluster_id: None,
                    cluster_rank: None,
-                    editor_why: None,
                },
            )
            .await
@@ -958,7 +945,6 @@ pub(crate) mod tests {
                rank_utility: None,
                cluster_id: None,
                cluster_rank: None,
-                editor_why: None,
            },
        )
        .await
@@ -1008,9 +994,9 @@ pub(crate) mod tests {
        .unwrap();
        sqlx::query(
            "INSERT INTO issue_articles
-             (issue_date, article_id, section, position, is_lead, summary, why)
-             VALUES (?, 1, 'Top Stories', 0, 1, 'Summary one', 'Why one'),
-                    (?, 2, 'Top Stories', 1, 0, 'Summary two', 'Why two')",
+             (issue_date, article_id, section, position, is_lead, summary)
+             VALUES (?, 1, 'Top Stories', 0, 1, 'Summary one'),
+                    (?, 2, 'Top Stories', 1, 0, 'Summary two')",
        )
        .bind(date.to_string())
        .bind(date.to_string())
@@ -506,7 +506,6 @@ pub struct CandidateView {
    pub fit: String,
    pub exploration: bool,
    pub auto_include: bool,
-    pub editor_why: Option<String>,
    pub signals: SignalsView,
 }

@@ -541,7 +540,6 @@ impl CandidateView {
            fit: fmt_opt(row.get("fit"), 1),
            exploration: signals.exploration,
            auto_include: signals.auto_include,
-            editor_why: row.get("editor_why"),
            signals,
        }
    }
@@ -575,7 +573,7 @@ pub async fn candidates(
        "SELECT cr.article_id, COALESCE(a.title, '') AS title,
                COALESCE(e.feed_title, '') AS feed_title, a.word_count,
                cr.stage, cr.excluded_reason, cr.admitted_by, cr.signals_json, cr.utility,
-                cr.rank_utility, cr.cluster_id, cr.cluster_rank, cr.editor_why,
+                cr.rank_utility, cr.cluster_id, cr.cluster_rank,
                t.score AS triage, d.score AS quality, d.fit AS fit
         {CANDIDATE_FROM}{clauses}
         ORDER BY {}
@@ -964,8 +962,6 @@ mod tests {
        assert_eq!(rows[0].article_id, 1);
        assert_eq!(rows[0].admitted_first.as_deref(), Some("triage"));
        assert_eq!(rows[0].admitted_rest, "interest");
-        assert_eq!(rows[0].editor_why.as_deref(), Some("Why one"));
-
        let by_rank = CandidateFilters::from_query(&query(None, Some("rank")));
        let (rows, _) = candidates(db, seed.run_id, &by_rank, 1).await.unwrap();
        assert_eq!(rows[0].rank, "1");
@@ -1099,7 +1095,6 @@ mod tests {
            "near miss: {detail}"
        );
        assert!(detail.contains("Gaussian Splatting"), "signals: {detail}");
-        assert!(detail.contains("Why one"), "{detail}");
        assert!(detail.contains("Alpha Blog"), "{detail}");
        assert!(detail.contains("class=\"funnel\""), "{detail}");
        assert!(
@@ -353,7 +353,7 @@ pub const SETTINGS_HELP: &[(&str, &str)] = &[
    ("curation.ranking.affinity_full", "Interest-attributable ratings at which affinity reaches full weight. Must be > affinity_floor."),
    ("curation.ranking.semantic_min_words", "Bodies shorter than this are not embedded."),
    ("curation.ranking.exploration_slots", "Shortlist slots reserved for exploration picks."),
-    ("curation.ranking.embedding_retention_days", "features prune: unrated, unpublished vectors older than this are deleted."),
+    ("curation.ranking.embedding_retention_days", "features prune: unrated, unpublished vectors older than this are deleted; 0 keeps them forever."),
    ("curation.ranking.telemetry_retention_days", "features prune: candidate_runs and article_assessments older than this are deleted."),
    ("curation.ranking.quotas.triage", "Deep-set slots filled by triage score."),
    ("curation.ranking.quotas.interest", "Deep-set slots filled by interest similarity."),
@@ -119,7 +119,7 @@ pub async fn load(
        (issue, true)
    } else {
        let rows = sqlx::query(
-            "SELECT article_id, section, position, is_lead, summary, why
+            "SELECT article_id, section, position, is_lead, summary
             FROM issue_articles WHERE issue_date = ? ORDER BY section, position",
        )
        .bind(date.to_string())
@@ -148,7 +148,6 @@ pub async fn load(
                section,
                position: pick_row.get("position"),
                is_lead: pick_row.get("is_lead"),
-                why: pick_row.get("why"),
                summary,
                llm: None,
                top_interests: Vec::new(),
@@ -881,7 +880,6 @@ struct FullEntry {
    reading_minutes: i64,
    is_lead: bool,
    summary: String,
-    why: Option<String>,
    understanding: chapters::Understanding,
    rating: Option<RatingWidget>,
 }
@@ -945,24 +943,74 @@ struct ArticleLink {
 struct ArticleTemplate {
    page: Page,
    toc: Toc,
+    head: ArticleHead,
+    discussion_html: Option<String>,
+    rating: Option<RatingWidget>,
+    previous: Option<ArticleLink>,
+    next: Option<ArticleLink>,
+    issue_href: String,
+    related: Vec<RelatedView>,
+}
+
+/// An archive article that never ran in an issue, reached from a related list:
+/// the stored body with no summary, rating or issue navigation.
+#[derive(Template)]
+#[template(path = "article_standalone.html")]
+struct StandaloneArticleTemplate {
+    page: Page,
+    head: ArticleHead,
+}
+
+/// What `_article_head.html` renders (header and body) plus the footer links
+/// both article pages share.
+struct ArticleHead {
    title: String,
    source_url: String,
    byline: Option<String>,
    source: Source,
    meta_line: String,
-    why: Option<String>,
    social_line: Option<String>,
+    /// Issue-only: empty and `None` on the standalone page.
    understanding: chapters::Understanding,
    summary: Option<String>,
    excerpt_only: bool,
    body_html: String,
-    discussion_html: Option<String>,
    read_online_url: String,
    dashboard_href: String,
-    rating: Option<RatingWidget>,
-    previous: Option<ArticleLink>,
-    next: Option<ArticleLink>,
-    issue_href: String,
+}
+
+impl ArticleHead {
+    fn new(article: &Article, config: &Config, is_admin: bool) -> Self {
+        Self {
+            title: article.title.clone(),
+            source_url: article.canonical_url.clone(),
+            byline: article.author.as_ref().map(|author| format!("By {author}")),
+            source: Source::new(article, config, is_admin),
+            meta_line: format!(
+                "{} words · ~{} min read",
+                thousands(article.word_count),
+                article.reading_minutes()
+            ),
+            social_line: chapters::social_line(&article.social),
+            understanding: chapters::Understanding::default(),
+            summary: None,
+            excerpt_only: article.excerpt_only,
+            body_html: prepare_body(&article.content_html),
+            read_online_url: article.url.clone(),
+            dashboard_href: format!("/dashboard/articles/{}", article.id),
+        }
+    }
+}
+
+/// One entry of the "Related" list under an issue article.
+#[derive(Debug)]
+struct RelatedView {
+    title: String,
+    href: String,
+    author: Option<String>,
+    source: Source,
+    reading_minutes: i64,
+    date: String,
 }

 #[derive(Template)]
@@ -1029,7 +1077,6 @@ pub async fn render_full(
                    summary: summary_for(&view.issue, pick)
                        .unwrap_or_default()
                        .to_string(),
-                    why: pick.why.clone(),
                    understanding: chapters::understanding(pick),
                    rating: is_admin.then(|| {
                        RatingWidget::for_issue(
@@ -1118,32 +1165,21 @@ pub async fn article(
    let is_admin = viewer.role == crate::web::users::Role::Admin;
    let config = state.config();
    let active_nav = if view.is_latest { "latest" } else { "archive" };
+    let related = related_views(&state.db, &config, is_admin, date, article_id).await?;
    let mut page = Page::new(article.title.clone(), Some(viewer.clone()), active_nav);
    page.flash = take_flash(&session).await?;
    Ok(Html(ArticleTemplate {
        page,
        toc,
-        title: article.title.clone(),
-        source_url: article.canonical_url.clone(),
-        byline: article.author.as_ref().map(|author| format!("By {author}")),
-        source: Source::new(article, &config, is_admin),
-        meta_line: format!(
-            "{} words · ~{} min read",
-            thousands(article.word_count),
-            article.reading_minutes()
-        ),
-        why: pick.why.clone(),
-        social_line: chapters::social_line(&article.social),
+        head: ArticleHead {
            understanding: chapters::understanding(pick),
            summary: summary_for(&view.issue, pick).map(str::to_string),
-        excerpt_only: article.excerpt_only,
-        body_html: prepare_body(&article.content_html),
+            ..ArticleHead::new(article, &config, is_admin)
+        },
        discussion_html: pick
            .discussion
            .as_ref()
            .map(|discussion| crate::comments::render_xhtml(discussion, &article.title)),
-        read_online_url: article.url.clone(),
-        dashboard_href: format!("/dashboard/articles/{}", article.id),
        rating: is_admin.then(|| {
            RatingWidget::for_issue(
                article.id,
@@ -1155,10 +1191,90 @@ pub async fn article(
        previous,
        next,
        issue_href: issue_href(date),
+        related,
    })
    .into_response())
 }

+/// `/articles/{id}`: any stored article on its own page. One that ran in an
+/// issue redirects to its (latest) issue page, which carries the summary and
+/// related list.
+pub async fn standalone(
+    State(state): State<AppState>,
+    auth: AuthSession,
+    Extension(session): Extension<Session>,
+    Path(article_id): Path<ArticleId>,
+) -> Result<Response, WebError> {
+    let viewer = auth
+        .user()
+        .await
+        .map(Viewer::from)
+        .ok_or_else(|| WebError::Unauthenticated {
+            next: standalone_href(article_id),
+        })?;
+    let Some(article) = state.db.get_article(article_id).await? else {
+        return Err(WebError::NotFound);
+    };
+    if let Some(date) = crate::related::latest_issues(&state.db, &[article_id])
+        .await?
+        .remove(&article_id)
+    {
+        return Ok(Redirect::to(&article_href(date, article_id)).into_response());
+    }
+    let is_admin = viewer.role == crate::web::users::Role::Admin;
+    let config = state.config();
+    let mut page = Page::new(article.title.clone(), Some(viewer), "archive");
+    page.flash = take_flash(&session).await?;
+    Ok(Html(StandaloneArticleTemplate {
+        page,
+        head: ArticleHead::new(&article, &config, is_admin),
+    })
+    .into_response())
+}
+
+/// The stored related links of one pick, each pointing at the issue page it
+/// ran on or, failing that, its standalone page.
+async fn related_views(
+    db: &Db,
+    config: &Config,
+    is_admin: bool,
+    date: Date,
+    article_id: ArticleId,
+) -> anyhow::Result<Vec<RelatedView>> {
+    let ids = crate::related::for_article(db, date, article_id).await?;
+    if ids.is_empty() {
+        return Ok(Vec::new());
+    }
+    let articles = db.get_articles(&ids).await?;
+    let issues = crate::related::latest_issues(db, &ids).await?;
+    Ok(ids
+        .iter()
+        .filter_map(|id| {
+            let article = articles.get(id)?;
+            let href = match issues.get(id) {
+                Some(date) => article_href(*date, article.id),
+                None => standalone_href(article.id),
+            };
+            Some(RelatedView {
+                title: article.title.clone(),
+                href,
+                author: article.author.clone(),
+                source: Source::new(article, config, is_admin),
+                reading_minutes: article.reading_minutes(),
+                date: short_date(article.published_at.unwrap_or(article.first_seen), config),
+            })
+        })
+        .collect())
+}
+
+/// "Aug 15, 2026" in the configured zone.
+fn short_date(timestamp: jiff::Timestamp, config: &Config) -> String {
+    match config.tz() {
+        Ok(tz) => timestamp.to_zoned(tz).strftime("%b %-d, %Y").to_string(),
+        Err(_) => timestamp.strftime("%b %-d, %Y").to_string(),
+    }
+}
+
 pub async fn world(
    State(state): State<AppState>,
    auth: AuthSession,
@@ -1340,6 +1456,10 @@ fn article_href(date: Date, article_id: ArticleId) -> String {
    format!("/issues/{date}/articles/{article_id}")
 }

+fn standalone_href(article_id: ArticleId) -> String {
+    format!("/articles/{article_id}")
+}
+
 fn issue_href(date: Date) -> String {
    format!("/issues/{date}")
 }
@@ -1420,7 +1540,7 @@ fn thousands(value: i64) -> String {
 /// Sanitize article HTML exactly as the EPUB does, then add browser-only image
 /// loading/referrer attributes without converting the fragment to XHTML.
 fn prepare_body(html: &str) -> String {
-    let clean = ammonia::clean(html);
+    let clean = crate::highlight::clean_and_highlight(html);
    let mut output = String::with_capacity(clean.len() + 64);
    let mut cursor = 0usize;
    while let Some(relative) = clean[cursor..].find('<') {
@@ -1636,7 +1756,6 @@ mod tests {
                    rank_utility: Some(3),
                    cluster_id: Some(1),
                    cluster_rank: Some(2),
-                    editor_why: None,
                },
            )
            .await
@@ -1844,7 +1963,6 @@ mod tests {
        assert!(html.contains("The Lead Story"));
        assert!(html.contains("Hacker News"));
        assert!(html.contains("What it argues, and why it is worth the time."));
-        assert!(html.contains("Why it's here"));
        assert!(!html.contains("Two stories today"));
        assert!(!html.contains("Something happened"));
        assert!(!html.contains("Body of"));
@@ -1895,20 +2013,75 @@ mod tests {
        )
        .unwrap();
        let document = roxmltree::Document::parse(&feed).unwrap();
-        assert_eq!(
-            document
+        let atom_entries = document
            .descendants()
            .filter(|node| node.tag_name().name() == "entry")
-                .count(),
-            1
-        );
+            .count();
+        assert_eq!(atom_entries, 1);
        assert!(feed.contains("What it argues, and why it is worth the time."));
-        assert!(feed.contains("Why it&apos;s here"));
        assert!(!feed.contains("Something happened"));
        assert!(!feed.contains("Two stories today"));
        assert!(!feed.contains("Body of"));
        assert!(!feed.contains("write path"));

+        let json = app
+            .clone()
+            .oneshot(
+                Request::builder()
+                    .uri("/feed.json")
+                    .body(Body::empty())
+                    .unwrap(),
+            )
+            .await
+            .unwrap();
+        assert_eq!(
+            json.headers().get(header::CONTENT_TYPE).unwrap(),
+            "application/feed+json; charset=utf-8"
+        );
+        assert_eq!(
+            json.headers().get(header::CACHE_CONTROL).unwrap(),
+            "public, max-age=300"
+        );
+        let json: serde_json::Value =
+            serde_json::from_slice(&to_bytes(json.into_body(), 1024 * 1024).await.unwrap())
+                .unwrap();
+        assert_eq!(json["version"], "https://jsonfeed.org/version/1.1");
+        let items = json["items"].as_array().unwrap();
+        assert_eq!(items.len(), atom_entries);
+        let item = &items[0];
+        assert!(item["id"].as_str().unwrap().starts_with("tag:"), "{item}");
+        assert!(
+            item["url"]
+                .as_str()
+                .unwrap()
+                .ends_with(&format!("/issues/{}", source.meta.date)),
+            "{item}"
+        );
+        assert!(
+            item["title"]
+                .as_str()
+                .unwrap()
+                .starts_with("The Daily EPUB — "),
+            "{item}"
+        );
+        let content_html = item["content_html"].as_str().unwrap();
+        assert!(content_html.contains("<h2>"), "{content_html}");
+        assert!(
+            content_html.contains("<p class=\"meta\">A. Writer · Example Feed · example.com</p>"),
+            "{content_html}"
+        );
+        assert!(
+            content_html.contains(
+                "<p class=\"links\"><a href=\"https://news.ycombinator.com/item?id=40100000\">Hacker News</a></p>"
+            ),
+            "{content_html}"
+        );
+        assert!(!content_html.contains("</a> — "), "{content_html}");
+        assert!(
+            !item["date_published"].as_str().unwrap().is_empty(),
+            "{item}"
+        );
+
        let robots = app
            .clone()
            .oneshot(
@@ -2000,10 +2173,15 @@ mod tests {
        assert!(issue.contains("Two stories today"));
        assert!(issue.contains("What it argues"));
        assert!(issue.contains("A short abstract for the second piece"));
-        assert!(issue.contains("Why it"));
        assert!(issue.contains("Software engineering · Analysis"));
        assert!(issue.contains("copy-on-write · ZFS"));
-        assert!(issue.contains("Matches: Filesystems · Rust"));
+        assert!(issue.contains("<span class=\"interest-chip\">Filesystems</span>"));
+        assert!(issue.contains("<span class=\"interest-chip\">Rust</span>"));
+        let issue_rubric_position = issue.find("Software engineering · Analysis").unwrap();
+        let issue_matches_position = issue.find("Matched interests: </span>").unwrap();
+        let issue_summary_position = issue.find("What it argues").unwrap();
+        assert!(issue_rubric_position < issue_matches_position);
+        assert!(issue_matches_position < issue_summary_position);
        assert!(issue.contains("A. Writer · Example Feed"));
        assert!(!issue.contains("example feed · Example Feed"));
        assert!(issue.contains("World Briefing"));
@@ -2036,13 +2214,15 @@ mod tests {
        assert!(article.contains("loading=\"lazy\""));
        assert!(article.contains("referrerpolicy=\"no-referrer\""));
        let rubric_position = article.find("Software engineering · Analysis").unwrap();
-        let why_position = article.find("Why it's here").unwrap();
+        let matches_position = article.find("Matched interests: </span>").unwrap();
+        assert!(article.contains("<span class=\"interest-chip\">Filesystems</span>"));
+        assert!(article.contains("<span class=\"interest-chip\">Rust</span>"));
        let summary_position = article
            .find("What it argues, and why it is worth the time.")
            .unwrap();
        let social_position = article.find("342 on HN").unwrap();
-        assert!(rubric_position < why_position);
-        assert!(why_position < summary_position);
+        assert!(rubric_position < matches_position);
+        assert!(matches_position < summary_position);
        assert!(summary_position < social_position);
        assert!(article.contains("A Niche Delight"));
        assert!(article.contains("rel=\"next\""));
@@ -2143,6 +2323,98 @@ mod tests {
        assert!(!reader.contains(&feed_href));
    }

+    #[tokio::test]
+    async fn related_links_reach_issue_pages_and_standalone_archive_articles() {
+        let (_dir, db, source) = seeded_issue(true).await;
+        crate::web::users::add(&db, "reader", "correct horse battery", false)
+            .await
+            .unwrap();
+        let pick = &source.lineup.picks[0].article;
+        let sibling = &source.lineup.picks[1].article;
+        let mut archived = pick.clone();
+        archived.id = 0;
+        archived.canonical_url = "https://example.com/archived-story".into();
+        archived.title = "An archived story nobody picked".into();
+        archived.content_html = "<p>Archived body text.</p>".into();
+        let archived_id = db.upsert_article(&archived).await.unwrap();
+        for (position, related_id) in [archived_id, sibling.id].into_iter().enumerate() {
+            sqlx::query(
+                "INSERT INTO issue_related (issue_date, article_id, position, related_id, cosine)
+                 VALUES (?, ?, ?, ?, 0.8)",
+            )
+            .bind(source.meta.date.to_string())
+            .bind(pick.id)
+            .bind(position as i64)
+            .bind(related_id)
+            .execute(db.pool())
+            .await
+            .unwrap();
+        }
+        let app = crate::server::router(crate::server::AppState::new(
+            db,
+            crate::config::Config::default(),
+            None,
+        ));
+        let cookie = login_cookie(&app, "reader", "correct horse battery").await;
+        let get = |uri: String, cookie: Option<String>| {
+            let app = app.clone();
+            async move {
+                let mut request = Request::builder().uri(uri);
+                if let Some(cookie) = cookie {
+                    request = request.header(header::COOKIE, cookie);
+                }
+                app.oneshot(request.body(Body::empty()).unwrap())
+                    .await
+                    .unwrap()
+            }
+        };
+
+        let page = response_text(
+            get(
+                format!("/issues/{}/articles/{}", source.meta.date, pick.id),
+                Some(cookie.clone()),
+            )
+            .await,
+        )
+        .await;
+        let related = page
+            .split_once("id=\"related-heading\"")
+            .expect("related list")
+            .1;
+        let archived_at = related
+            .find(&format!("href=\"/articles/{archived_id}\""))
+            .expect("unpicked article links to its standalone page");
+        let sibling_at = related
+            .find(&format!(
+                "href=\"/issues/{}/articles/{}\"",
+                source.meta.date, sibling.id
+            ))
+            .expect("a picked article links to its issue page");
+        assert!(archived_at < sibling_at, "stored order is kept");
+
+        let standalone = get(format!("/articles/{archived_id}"), Some(cookie.clone())).await;
+        assert_eq!(standalone.status(), StatusCode::OK);
+        let standalone = response_text(standalone).await;
+        assert!(standalone.contains("An archived story nobody picked"));
+        assert!(standalone.contains("Archived body text."));
+
+        let picked = get(format!("/articles/{}", pick.id), Some(cookie)).await;
+        assert_eq!(picked.status(), StatusCode::SEE_OTHER);
+        assert_eq!(
+            picked.headers()[header::LOCATION],
+            format!("/issues/{}/articles/{}", source.meta.date, pick.id)
+        );
+
+        let anonymous = get(format!("/articles/{archived_id}"), None).await;
+        assert!(anonymous.status().is_redirection());
+        assert!(
+            anonymous.headers()[header::LOCATION]
+                .to_str()
+                .unwrap()
+                .starts_with("/login")
+        );
+    }
+
    #[tokio::test]
    async fn fallback_full_issue_recovers_colophon_world_and_behind() {
        let (_dir, db, source) = seeded_issue(false).await;
@@ -2743,7 +3015,8 @@ mod tests {
        assert!(admin_issue.contains("Was this a good pick?"));
        assert!(admin_issue.contains("value=\"loved\" data-label=\"loved\" class=\"active\""));
        assert!(admin_issue.contains(&dashboard_href));
-        assert!(admin_issue.contains(&crate::interests::articles_href("Filesystems")));
+        let interest_href = crate::interests::articles_href("Filesystems");
+        assert!(admin_issue.contains(&format!("class=\"interest-chip\" href=\"{interest_href}\"")));

        let admin_article = app
            .clone()
@@ -681,6 +681,7 @@ pub fn router(config: &crate::config::Config) -> axum::Router<crate::server::App
        .route_layer(from_fn(session::require_password_change));
    let full_issues = axum::Router::new()
        .route("/issues/{date}/articles/{article_id}", get(issue::article))
+        .route("/articles/{article_id}", get(issue::standalone))
        .route("/issues/{date}/world", get(issue::world))
        .route("/issues/{date}/behind", get(issue::behind))
        .route("/issues/{date}/read", get(issue::read))
@@ -708,6 +709,7 @@ pub fn router(config: &crate::config::Config) -> axum::Router<crate::server::App
        .route("/issues", get(public::archive))
        .route("/issues/{date}", get(public::show_issue))
        .route("/feed.xml", get(public::feed))
+        .route("/feed.json", get(public::feed_json))
        .route("/robots.txt", get(public::robots))
        .route("/static/{file}", get(static_asset))
        .merge(access_routes)
@@ -4,6 +4,7 @@ use axum::http::{HeaderMap, StatusCode, header};
 use axum::response::{IntoResponse, Response};
 use axum_login::tower_sessions::Session;
 use jiff::civil::Date;
+use serde::Serialize;

 use crate::server::AppState;
 use crate::types::{Issue, SocialSource};
@@ -53,7 +54,6 @@ pub struct PublicEntry {
    pub reading_minutes: i64,
    pub word_count: i64,
    pub summary: Option<String>,
-    pub why: Option<String>,
    pub understanding: crate::epub::chapters::Understanding,
    pub comment_links: Vec<CommentLink>,
    pub is_lead: bool,
@@ -132,7 +132,6 @@ impl From<&Issue> for PublicIssue {
                                    .map(str::trim)
                                    .filter(|summary| !summary.is_empty())
                                    .map(str::to_string),
-                                why: pick.why.clone(),
                                understanding: crate::epub::chapters::understanding(pick),
                                comment_links,
                                is_lead: pick.is_lead,
@@ -291,10 +290,25 @@ pub async fn archive(
    Ok(public_cache(response, &headers))
 }

-pub async fn feed(State(state): State<AppState>) -> Result<Response, WebError> {
+/// One issue as both public feeds carry it.
+///
+/// Atom and JSON Feed differ only in how these five fields are spelled out, so
+/// the expensive part — loading the issue and rendering `feed_entry.html` — is
+/// done once, by [`feed_entries`], and shared.
+struct FeedEntry {
+    id: String,
+    href: String,
+    title: String,
+    generated_at: jiff::Timestamp,
+    content: String,
+}
+
+/// The last 30 issues, newest first, plus the newest `generated_at` among them
+/// (the feed-level `<updated>`).
+async fn feed_entries(state: &AppState) -> Result<(Vec<FeedEntry>, jiff::Timestamp), WebError> {
    let config = state.config();
    let rows = state.db.issue_dates(Some(30)).await?;
-    let mut entries = String::new();
+    let mut entries = Vec::new();
    let mut updated = jiff::Timestamp::UNIX_EPOCH;
    for row in rows {
        let Some(view) = issue::load(&state.db, &config, row.date).await? else {
@@ -308,20 +322,38 @@ pub async fn feed(State(state): State<AppState>) -> Result<Response, WebError> {
        let content = FeedEntryTemplate { issue: &issue }.render();
        crate::web::timing::record_render(started.elapsed());
        let content = content.map_err(|error| WebError::Internal(error.into()))?;
-        let href = format!(
+        entries.push(FeedEntry {
+            id: format!(
+                "tag:{},{}:issue/{}",
+                feed_host(&config.server.public_url),
+                issue.date.year(),
+                issue.date
+            ),
+            href: format!(
                "{}/issues/{}",
                config.server.public_url.trim_end_matches('/'),
                issue.date
-        );
+            ),
+            title: format!("The Daily EPUB — {}", issue.date),
+            generated_at: issue.generated_at,
+            content,
+        });
+    }
+    Ok((entries, updated))
+}
+
+pub async fn feed(State(state): State<AppState>) -> Result<Response, WebError> {
+    let config = state.config();
+    let (issues, updated) = feed_entries(&state).await?;
+    let mut entries = String::new();
+    for entry in &issues {
        entries.push_str(&format!(
-            "<entry><id>tag:{},{}:issue/{}</id><title>The Daily EPUB — {}</title><updated>{}</updated><link rel=\"alternate\" href=\"{}\"/><content type=\"html\">{}</content></entry>",
-            feed_host(&config.server.public_url),
-            issue.date.year(),
-            issue.date,
-            issue.date,
-            issue.generated_at,
-            xml_escape(&href),
-            xml_escape(&content),
+            "<entry><id>{}</id><title>{}</title><updated>{}</updated><link rel=\"alternate\" href=\"{}\"/><content type=\"html\">{}</content></entry>",
+            entry.id,
+            entry.title,
+            entry.generated_at,
+            xml_escape(&entry.href),
+            xml_escape(&entry.content),
        ));
    }
    let home = config.server.public_url.trim_end_matches('/');
@@ -343,6 +375,59 @@ pub async fn feed(State(state): State<AppState>) -> Result<Response, WebError> {
        .into_response())
 }

+/// JSON Feed 1.1 <https://jsonfeed.org/version/1.1>, the same issues `/feed.xml`
+/// carries.
+#[derive(Serialize)]
+struct JsonFeed<'a> {
+    version: &'static str,
+    title: &'static str,
+    home_page_url: &'a str,
+    feed_url: String,
+    items: Vec<JsonFeedItem<'a>>,
+}
+
+#[derive(Serialize)]
+struct JsonFeedItem<'a> {
+    id: &'a str,
+    url: &'a str,
+    title: &'a str,
+    /// The rendered `feed_entry.html`, raw: JSON escaping is serde's job.
+    content_html: &'a str,
+    date_published: String,
+}
+
+pub async fn feed_json(State(state): State<AppState>) -> Result<Response, WebError> {
+    let config = state.config();
+    let (entries, _updated) = feed_entries(&state).await?;
+    let home = config.server.public_url.trim_end_matches('/');
+    let body = serde_json::to_string(&JsonFeed {
+        version: "https://jsonfeed.org/version/1.1",
+        title: "The Daily EPUB",
+        home_page_url: home,
+        feed_url: format!("{home}/feed.json"),
+        items: entries
+            .iter()
+            .map(|entry| JsonFeedItem {
+                id: &entry.id,
+                url: &entry.href,
+                title: &entry.title,
+                content_html: &entry.content,
+                date_published: entry.generated_at.to_string(),
+            })
+            .collect(),
+    })
+    .map_err(|error| WebError::Internal(error.into()))?;
+    Ok((
+        StatusCode::OK,
+        [
+            (header::CONTENT_TYPE, "application/feed+json; charset=utf-8"),
+            (header::CACHE_CONTROL, PUBLIC_CACHE),
+        ],
+        body,
+    )
+        .into_response())
+}
+
 pub async fn robots() -> Response {
    (
        StatusCode::OK,
@@ -423,7 +508,7 @@ mod tests {
    use super::*;

    #[test]
-    fn public_issue_shows_summaries_and_why_but_no_bodies() {
+    fn public_issue_shows_summaries_but_no_bodies() {
        let source = crate::epub::fixtures::issue();
        let public = PublicIssue::from(&source);
        assert_eq!(
@@ -442,19 +527,20 @@ mod tests {
        assert!(html.contains("Hacker News"));
        assert!(html.contains("What it argues, and why it is worth the time."));
        assert!(html.contains("A short abstract for the second piece."));
-        assert!(html.contains("The systems story with enough operational detail to matter"));
-        assert!(html.contains("A small-scene delight outside the usual technical orbit"));
+        assert!(!html.contains("The systems story with enough operational detail to matter"));
+        assert!(!html.contains("A small-scene delight outside the usual technical orbit"));
        assert!(html.contains("Software engineering · Analysis"));
        assert!(html.contains("copy-on-write · ZFS"));
-        assert!(html.contains("Matches: Filesystems · Rust"));
+        assert!(html.contains("<span class=\"interest-chip\">Filesystems</span>"));
+        assert!(html.contains("<span class=\"interest-chip\">Rust</span>"));
        let rubric_position = html.find("Software engineering · Analysis").unwrap();
-        let why_position = html.find("Why it's here").unwrap();
+        let matches_position = html.find("Matched interests: </span>").unwrap();
        let summary_position = html
            .find("What it argues, and why it is worth the time.")
            .unwrap();
        let comments_position = html.find(">Hacker News:").unwrap();
-        assert!(rubric_position < why_position);
-        assert!(why_position < summary_position);
+        assert!(rubric_position < matches_position);
+        assert!(matches_position < summary_position);
        assert!(summary_position < comments_position);
        for private in [
            "Two stories today",
@@ -467,4 +553,35 @@ mod tests {
            assert!(!html.contains(private), "leaked {private:?} in {html}");
        }
    }
+
+    #[test]
+    fn feed_entry_wraps_byline_and_links_in_paragraphs() {
+        let mut source = crate::epub::fixtures::issue();
+        // A second comment link, so the separator between links is exercised.
+        source.lineup.picks[0].article.comments_url =
+            Some("https://example.com/discuss".to_string());
+        let issue = PublicIssue::from(&source);
+        let html = FeedEntryTemplate { issue: &issue }.render().unwrap();
+
+        assert!(html.contains("<h2>Top Stories</h2><ul>"), "{html}");
+        assert!(
+            html.contains(
+                "<li><a href=\"https://example.com/1001\">The Lead Story</a><p class=\"meta\">A. Writer · Example Feed · example.com</p>"
+            ),
+            "{html}"
+        );
+        assert!(
+            html.contains("<p class=\"summary\">What it argues, and why it is worth the time.</p>"),
+            "{html}"
+        );
+        assert!(
+            html.contains(
+                "<p class=\"links\"><a href=\"https://news.ycombinator.com/item?id=40100000\">Hacker News</a> · <a href=\"https://example.com/discuss\">Comments</a></p></li>"
+            ),
+            "{html}"
+        );
+        // The old run-together byline and adjacent links are gone.
+        assert!(!html.contains("</a> — "), "{html}");
+        assert!(!html.contains("Hacker News</a><a "), "{html}");
+    }
 }
@@ -1,2 +1,2 @@
 /*! tailwindcss v4.3.3 | MIT License | https://tailwindcss.com */
-@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-rotate-x:initial;--tw-rotate-y:initial;--tw-rotate-z:initial;--tw-skew-x:initial;--tw-skew-y:initial;--tw-space-y-reverse:0;--tw-divide-y-reverse:0;--tw-border-style:solid;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-outline-style:solid;--tw-blur:initial;--tw-brightness:initial;--tw-contrast:initial;--tw-grayscale:initial;--tw-hue-rotate:initial;--tw-invert:initial;--tw-opacity:initial;--tw-saturate:initial;--tw-sepia:initial;--tw-drop-shadow:initial;--tw-drop-shadow-color:initial;--tw-drop-shadow-alpha:100%;--tw-drop-shadow-size:initial;--tw-duration:initial}}}@layer theme{:root,:host{--font-sans:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--font-serif:"Newsreader", "Newsreader Fallback Georgia", "Newsreader Fallback Times", "Newsreader Fallback Noto Serif", "Newsreader Fallback DejaVu Serif", "Iowan Old Style", "Palatino Linotype", Georgia, serif;--font-mono:ui-monospace, SFMono-Regular, Menlo, monospace;--spacing:.25rem;--container-md:28rem;--container-lg:32rem;--container-2xl:42rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height:calc(1.5 / 1);--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height:calc(2.25 / 1.875);--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--tracking-normal:0em;--leading-tight:1.25;--leading-snug:1.375;--leading-normal:1.5;--leading-relaxed:1.625;--radius-sm:.25rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, SFMono-Regular, Menlo, monospace;--color-paper:var(--paper);--color-paper-2:var(--paper-2);--color-ink:var(--ink)}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-vaLine truncated
+@layer properties{@supports (((-webkit-hyphens:none)) and (not (margin-trim:inline))) or ((-moz-orient:inline) and (not (color:rgb(from red r g b)))){*,:before,:after,::backdrop{--tw-translate-x:0;--tw-translate-y:0;--tw-translate-z:0;--tw-space-y-reverse:0;--tw-divide-y-reverse:0;--tw-border-style:solid;--tw-leading:initial;--tw-font-weight:initial;--tw-tracking:initial;--tw-ordinal:initial;--tw-slashed-zero:initial;--tw-numeric-figure:initial;--tw-numeric-spacing:initial;--tw-numeric-fraction:initial;--tw-shadow:0 0 #0000;--tw-shadow-color:initial;--tw-shadow-alpha:100%;--tw-inset-shadow:0 0 #0000;--tw-inset-shadow-color:initial;--tw-inset-shadow-alpha:100%;--tw-ring-color:initial;--tw-ring-shadow:0 0 #0000;--tw-inset-ring-color:initial;--tw-inset-ring-shadow:0 0 #0000;--tw-ring-inset:initial;--tw-ring-offset-width:0px;--tw-ring-offset-color:#fff;--tw-ring-offset-shadow:0 0 #0000;--tw-duration:initial}}}@layer theme{:root,:host{--spacing:.25rem;--container-md:28rem;--container-lg:32rem;--container-2xl:42rem;--container-7xl:80rem;--text-xs:.75rem;--text-xs--line-height:calc(1 / .75);--text-sm:.875rem;--text-sm--line-height:calc(1.25 / .875);--text-base:1rem;--text-base--line-height:calc(1.5 / 1);--text-lg:1.125rem;--text-lg--line-height:calc(1.75 / 1.125);--text-xl:1.25rem;--text-xl--line-height:calc(1.75 / 1.25);--text-2xl:1.5rem;--text-2xl--line-height:calc(2 / 1.5);--text-3xl:1.875rem;--text-3xl--line-height:calc(2.25 / 1.875);--text-4xl:2.25rem;--text-4xl--line-height:calc(2.5 / 2.25);--text-5xl:3rem;--text-5xl--line-height:1;--font-weight-normal:400;--font-weight-medium:500;--font-weight-semibold:600;--tracking-normal:0em;--leading-tight:1.25;--leading-snug:1.375;--leading-normal:1.5;--leading-relaxed:1.625;--radius-xs:.125rem;--radius-sm:.25rem;--default-transition-duration:.15s;--default-transition-timing-function:cubic-bezier(.4, 0, .2, 1);--default-font-family:ui-sans-serif, system-ui, -apple-system, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;--default-mono-font-family:ui-monospace, SFMono-Regular, Menlo, monospace}}@layer base{*,:after,:before,::backdrop{box-sizing:border-box;border:0 solid;margin:0;padding:0}::file-selector-button{box-sizing:border-box;border:0 solid;margin:0;padding:0}html,:host{-webkit-text-size-adjust:100%;tab-size:4;line-height:1.5;font-family:var(--default-font-family,-apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", "Noto Sans", Arial, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");font-feature-settings:var(--default-font-feature-settings,normal);font-variation-settings:var(--default-font-variation-settings,normal);-webkit-tap-highlight-color:transparent}hr{height:0;color:inherit;border-top-width:1px}abbr:where([title]){-webkit-text-decoration:underline dotted;text-decoration:underline dotted}h1,h2,h3,h4,h5,h6{font-size:inherit;font-weight:inherit}a{color:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;-webkit-text-decoration:inherit;text-decoration:inherit}b,strong{font-weight:bolder}code,kbd,samp,pre{font-family:var(--default-mono-font-family,ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);font-feature-settings:var(--default-mono-font-feature-settings,normal);font-variation-settings:var(--default-mono-font-variation-settings,normal);font-size:1em}small{font-size:80%}sub,sup{vertical-align:baseline;font-size:75%;line-height:0;position:relative}sub{bottom:-.25em}sup{top:-.5em}table{text-indent:0;border-color:inherit;border-collapse:collapse}:-moz-focusring:where(:not(iframe)){outline:auto}progress{vertical-align:baseline}summary{display:list-item}ol,ul,menu{list-style:none}img,svg,video,canvas,audio,iframe,embed,object{vertical-align:middle;display:block}img,video{max-width:100%;height:auto}button,input,select,optgroup,textarea{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}::file-selector-button{font:inherit;font-feature-settings:inherit;font-variation-settings:inherit;letter-spacing:inherit;color:inherit;opacity:1;background-color:#0000;border-radius:0}:where(select:is([multiple],[size])) optgroup{font-weight:bolder}:where(select:is([multiple],[size])) optgroup option{padding-inline-start:20px}::file-selector-button{margin-inline-end:4px}::placeholder{opacity:1}@supports (not ((-webkit-appearance:-apple-pay-button))) or (contain-intrinsic-size:1px){::placeholder{color:currentColor}@supports (color:color-mix(in lab, red, red)){::placeholder{color:color-mix(in oklab, currentcolor 50%, transparent)}}}textarea{resize:vertical}::-webkit-search-decoration{-webkit-appearance:none}::-webkit-date-and-time-value{min-height:1lh;text-align:inherit}::-webkit-datetime-edit{display:inline-flex}::-webkit-datetime-edit-fields-wrapper{padding:0}::-webkit-datetime-edit{padding-block:0}::-webkit-datetime-edit-year-field{paddiLine truncated
@@ -1,4 +1,4 @@
-@import "tailwindcss";
+@import "tailwindcss" source(none);
@source "../web/templates";
@source "./static/app.js";

@@ -83,6 +83,7 @@
  --paper:#f6f3ec; --paper-2:#ece7db; --ink:#1c1b18; --ink-2:#4f4b43; --muted:#6b665a;
  --rule:#d8d2c4; --rule-strong:#1c1b18; --accent:#a3231f; --accent-hover:#7c1a16;
  --loved:#2f6f46; --good:#2f6a8f; --down:#9c3f36; --warn:#7d631c; color-scheme:light;
+  --hl-keyword:#8c2a22; --hl-string:#3b6246; --hl-number:#7a4f16; --hl-type:#2c5572;
 }

@media (prefers-color-scheme: dark) {
@@ -90,6 +91,7 @@
    --paper:#151513; --paper-2:#1e1d1a; --ink:#ebe6da; --ink-2:#bfb9aa; --muted:#8f8a7d;
    --rule:#3a3833; --rule-strong:#ebe6da; --accent:#ef8c82; --accent-hover:#f7aaa2;
    --loved:#7fcb92; --good:#7fb8d8; --down:#ea8f84; --warn:#d9b45a; color-scheme:dark;
+    --hl-keyword:#e3a197; --hl-string:#a3c9a9; --hl-number:#d8b77a; --hl-type:#9dbdd3;
  }
 }

@@ -97,6 +99,7 @@
  --paper:#151513; --paper-2:#1e1d1a; --ink:#ebe6da; --ink-2:#bfb9aa; --muted:#8f8a7d;
  --rule:#3a3833; --rule-strong:#ebe6da; --accent:#ef8c82; --accent-hover:#f7aaa2;
  --loved:#7fcb92; --good:#7fb8d8; --down:#ea8f84; --warn:#d9b45a; color-scheme:dark;
+  --hl-keyword:#e3a197; --hl-string:#a3c9a9; --hl-number:#d8b77a; --hl-type:#9dbdd3;
 }

@theme inline {
@@ -159,8 +162,8 @@
  .kv { @apply grid grid-cols-[minmax(9rem,1fr)_2fr] gap-x-5 gap-y-1.5; }
  .kv dt { @apply text-sm text-muted; }
  .kv dd { @apply m-0 min-w-0 text-sm; overflow-wrap:anywhere; }
+  /* Dashboard table layout contract: docs/dashboard-tables.md. */
  .scroll-x { @apply max-w-full overflow-x-auto; overscroll-behavior-inline:contain; }
-  .scroll-x > table { min-width:max-content; }
  .scroll-x.tall { @apply max-h-[70vh] overflow-y-auto; overscroll-behavior-block:contain; }

  .reader-page { @apply min-w-0; overflow-wrap:anywhere; }
@@ -178,6 +181,17 @@
  .prose-body th, .prose-body td { overflow-wrap:normal; }
  .prose-body pre { @apply max-w-full overflow-x-auto rounded-sm bg-paper-2 p-4 text-sm leading-relaxed; }
  .prose-body :not(pre) > code { @apply rounded-sm bg-paper-2 px-1 py-0.5 text-[0.9em]; }
+  /* Syntax tokens (src/highlight.rs): ink-first, with a few print colours —
+     oxblood keywords, bottle-green strings, umber literals, slate types. All at
+     least 4.5:1 on paper-2 in both themes. Names and variables stay ink. */
+  .hl-keyword, .hl-tag, .hl-diff-delete { color:var(--hl-keyword); }
+  .hl-string, .hl-diff-add { color:var(--hl-string); }
+  .hl-number, .hl-constant, .hl-macro, .hl-attribute, .hl-label { color:var(--hl-number); }
+  .hl-type, .hl-namespace, .hl-constructor { color:var(--hl-type); }
+  .hl-comment { color:var(--muted); font-style:italic; }
+  .hl-punctuation, .hl-operator { color:var(--ink-2); }
+  .hl-title, .hl-strong { font-weight:600; }
+  .hl-emphasis { font-style:italic; }
  .prose-body blockquote { @apply my-7 border-l-2 border-rule-strong pl-5 text-ink-2; }
  .prose-body ul { @apply list-disc pl-6; }
  .prose-body ol { @apply list-decimal pl-6; }
@@ -186,6 +200,12 @@

  .reader-page :where(h1, h2, h3, h4), .reader-section-heading { text-wrap:balance; }
  .reader-section-heading { @apply border-t-[3px] border-double border-rule-strong pt-3 font-serif text-[1.05rem] font-semibold uppercase leading-[1.2] tracking-[0.15em] text-ink; }
+  /* Matched-interest tags: a hairline in the divider colour with squared
+     corners, so the row reads as small print, not as buttons. */
+  .interest-chip { @apply inline-block rounded-xs border border-rule px-2 py-px text-xs leading-5 text-ink-2 no-underline; }
+  a.interest-chip { @apply relative; }
+  a.interest-chip::after { content:""; @apply absolute -inset-y-1.5 inset-x-0; }
+  a.interest-chip:hover { @apply border-accent text-accent; }

  .rating { @apply my-5 flex flex-wrap items-center gap-x-3 font-sans text-xs; }
  .rating-prompt { @apply font-serif text-[0.8rem] italic text-muted; }
@@ -213,7 +233,30 @@
  ul.error, ul.notice { @apply list-disc pl-8; }

  /* ---------- dashboard shell ---------- */
-  .dashboard { @apply mx-auto my-8 max-w-7xl px-4 pb-6 font-sans text-base leading-normal sm:px-6; }
+  .dashboard {
+    --gutter:1rem;
+    @apply my-8 grid pb-6 font-sans text-base leading-normal;
+    grid-template-columns:
+      [full-start] var(--gutter)
+      [wide-start] 1fr
+      [content-start] minmax(0, calc(80rem - 2 * var(--gutter)))
+      [content-end] 1fr
+      [wide-end] var(--gutter)
+      [full-end];
+  }
+  @media (width >= 40rem) { .dashboard { --gutter:1.5rem; } }
+  /* Grid items never collapse margins, so a child's bottom margin (`.table-filter`, `.rating`) would add to
+     the next child's `mt-4`; the rhythm comes from top margins only. `!important` beats those utilities. */
+  .dashboard > * { grid-column:content; min-width:0; margin-bottom:0 !important; }
+  /* The wrapper shrinks to its table (a centred grid item is sized fit-content), so the
+     flanks beside a narrow table stay page, not scroll container: wheeling there scrolls the page. */
+  .dashboard > .scroll-x {
+    grid-column:wide;
+    justify-self:center;
+    min-width:min(100%, calc(80rem - 2 * var(--gutter)));
+    max-width:100%;
+  }
+  .dashboard > .scroll-x > table { width:auto; min-width:100%; }
  .dashboard > * + * { @apply mt-4; }
  .dashboard h1 { @apply text-2xl font-semibold leading-tight tracking-[-0.01em]; }
  .dashboard h2 { @apply text-lg font-semibold; }
@@ -248,8 +291,9 @@

  .muted, .meta { @apply text-muted; }
  .jobs a, .picks > li > a:first-child { @apply text-ink no-underline hover:text-accent; }
-  .num { @apply whitespace-nowrap text-right tabular-nums; }
-  .cell-wrap { @apply min-w-[10rem] max-w-[24rem] whitespace-normal; overflow-wrap:anywhere; }
+  .num { @apply text-right tabular-nums; }
+  td.num { @apply whitespace-nowrap; }
+  .cell-wrap { @apply min-w-[10rem] max-w-[32rem] whitespace-normal; overflow-wrap:anywhere; }
  .cell-tight { @apply whitespace-nowrap; }

  .filters { @apply flex flex-wrap items-end gap-x-4 gap-y-3 border-y border-rule py-3 font-sans text-sm; }
@@ -0,0 +1,2 @@
+<header><p class="font-sans text-[0.72rem] uppercase tracking-[0.12em] text-muted">Article</p><h1 class="mt-3 text-4xl font-semibold leading-[1.1] tracking-[-0.01em] sm:text-5xl"><a class="text-ink no-underline hover:text-accent" href="{{ head.source_url }}">{{ head.title }}</a></h1>{% match head.byline %}{% when Some with (byline) %}<p class="mt-5 font-sans text-sm font-medium text-ink-2">{{ byline }}</p>{% when None %}{% endmatch %}<p class="mt-1 font-sans text-sm text-muted">{% let source = head.source %}{% include "_source.html" %} · {{ head.meta_line }}</p>{% let understanding = head.understanding %}{% include "_understanding.html" %}{% match head.summary %}{% when Some with (summary) %}<p class="mt-7 text-xl italic leading-relaxed text-ink-2">{{ summary }}</p>{% when None %}{% endmatch %}{% match head.social_line %}{% when Some with (social) %}<p class="mt-4 font-sans text-sm text-muted">{{ social }}</p>{% when None %}{% endmatch %}{% if head.excerpt_only %}<p class="notice mt-6">Excerpt only — continue reading at the original site.</p>{% endif %}</header>
+  <div class="prose-body mt-10 border-t border-rule pt-8">{{ head.body_html|safe }}</div>
@@ -1,16 +1,15 @@
 <tr>
 <td class="cell-wrap"><details class="signals"><summary><a href="{{ candidate.href }}">{{ candidate.title }}</a></summary>{% let signals = candidate.signals %}{% include "_signals_table.html" %}</details></td>
-<td class="cell-tight text-muted">{{ candidate.feed }}</td>
+<td class="text-muted">{{ candidate.feed }}</td>
 <td class="num">{{ candidate.words }}</td>
-<td class="cell-tight"><span class="badge {{ candidate.stage }}">{{ candidate.stage }}</span></td>
-<td class="cell-tight">{% if let Some(reason) = candidate.reason %}<span class="badge reason">{{ reason }}</span>{% endif %}</td>
-<td class="cell-tight text-muted">{% if let Some(first) = candidate.admitted_first %}{{ first }}{% if !candidate.admitted_rest.is_empty() %} <span class="muted text-xs">({{ candidate.admitted_rest }})</span>{% endif %}{% endif %}</td>
+<td><span class="badge {{ candidate.stage }}">{{ candidate.stage }}</span></td>
+<td>{% if let Some(reason) = candidate.reason %}<span class="badge reason">{{ reason }}</span>{% endif %}</td>
+<td class="text-muted">{% if let Some(first) = candidate.admitted_first %}{{ first }}{% if !candidate.admitted_rest.is_empty() %} <span class="muted text-xs">({{ candidate.admitted_rest }})</span>{% endif %}{% endif %}</td>
 <td class="num">{{ candidate.utility }}</td>
 <td class="num">{{ candidate.rank }}</td>
 <td class="num">{{ candidate.cluster }}</td>
 <td class="num">{{ candidate.triage }}</td>
 <td class="num">{{ candidate.quality }}</td>
 <td class="num">{{ candidate.fit }}</td>
-<td class="cell-tight">{% if candidate.exploration %}<span class="badge">exploration</span>{% endif %}{% if candidate.auto_include %}<span class="badge">auto</span>{% endif %}</td>
-<td class="cell-wrap text-muted">{% if let Some(why) = candidate.editor_why %}{{ why }}{% endif %}</td>
+<td>{% if candidate.exploration %}<span class="badge">exploration</span>{% endif %}{% if candidate.auto_include %}<span class="badge">auto</span>{% endif %}</td>
 </tr>
@@ -0,0 +1 @@
+{% if !related.is_empty() %}<section class="mt-12" aria-labelledby="related-heading"><h2 id="related-heading" class="reader-section-heading">Related</h2><ul class="m-0 list-none p-0">{% for item in related %}<li class="border-b border-rule py-5"><h3 class="font-serif text-xl font-semibold leading-[1.15] tracking-[-0.01em]"><a class="text-ink no-underline hover:text-accent" href="{{ item.href }}">{{ item.title }}</a></h3><p class="mt-1.5 font-sans text-sm text-muted">{% match item.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{% let source = item.source %}{% include "_source.html" %} · {{ item.reading_minutes }} min read · {{ item.date }}</p></li>{% endfor %}</ul></section>{% endif %}
@@ -1 +1 @@
-{% if understanding.kicker.is_some() || understanding.topics.is_some() %}<p class="mt-3 font-sans text-sm text-muted">{% if let Some(kicker) = understanding.kicker %}<span class="text-[0.72rem] uppercase tracking-[0.12em]">{{ kicker }}</span>{% if let Some(topics) = understanding.topics %}<span class="ml-3">{{ topics }}</span>{% endif %}{% else %}{% if let Some(topics) = understanding.topics %}<span>{{ topics }}</span>{% endif %}{% endif %}</p>{% endif %}{% if why.is_some() || !understanding.interests.is_empty() %}<div class="mt-4 border-l-2 border-accent pl-3">{% if let Some(why) = why %}<p class="italic text-ink-2">Why it's here: {{ why }}</p>{% endif %}{% if !understanding.interests.is_empty() %}<p class="mt-1 font-sans text-sm text-muted">Matches: {% for interest in understanding.interests %}{% if page.is_admin() %}<a href="{{ interest.href }}">{{ interest.name }}</a>{% else %}{{ interest.name }}{% endif %}{% if !loop.last %} · {% endif %}{% endfor %}</p>{% endif %}</div>{% endif %}
+{% if understanding.kicker.is_some() || understanding.topics.is_some() %}<p class="mt-3 font-sans text-sm text-muted">{% if let Some(kicker) = understanding.kicker %}<span class="text-[0.72rem] uppercase tracking-[0.12em]">{{ kicker }}</span>{% if let Some(topics) = understanding.topics %}<span class="ml-3">{{ topics }}</span>{% endif %}{% else %}{% if let Some(topics) = understanding.topics %}<span>{{ topics }}</span>{% endif %}{% endif %}</p>{% endif %}{% if !understanding.interests.is_empty() %}<p class="mt-2.5 flex flex-wrap items-center gap-1.5 font-sans"><span class="sr-only">Matched interests: </span>{% for interest in understanding.interests %}{% if page.is_admin() %}<a class="interest-chip" href="{{ interest.href }}">{{ interest.name }}</a>{% else %}<span class="interest-chip">{{ interest.name }}</span>{% endif %}{% endfor %}</p>{% endif %}
@@ -1,8 +1,8 @@
 {% extends "layout.html" %}{% block ears %}<span class="sm:hidden">{{ toc.short_date }}</span><span class="hidden sm:inline">{{ toc.display_date }} · No. {{ toc.issue_number }}</span>{% endblock %}{% block content %}<div class="mx-auto max-w-7xl lg:grid lg:grid-cols-[15rem_minmax(0,1fr)] lg:gap-x-8 lg:px-6 xl:grid-cols-[18rem_minmax(0,1fr)] xl:gap-x-14">{% include "_toc.html" %}
 <article class="reader-page mx-auto mt-10 w-full max-w-[68ch] px-4 sm:px-6 lg:mt-12 lg:px-0" data-toc-scroll>
-  <header><p class="font-sans text-[0.72rem] uppercase tracking-[0.12em] text-muted">Article</p><h1 class="mt-3 text-4xl font-semibold leading-[1.1] tracking-[-0.01em] sm:text-5xl"><a class="text-ink no-underline hover:text-accent" href="{{ source_url }}">{{ title }}</a></h1>{% match byline %}{% when Some with (byline) %}<p class="mt-5 font-sans text-sm font-medium text-ink-2">{{ byline }}</p>{% when None %}{% endmatch %}<p class="mt-1 font-sans text-sm text-muted">{% include "_source.html" %} · {{ meta_line }}</p>{% include "_understanding.html" %}{% match summary %}{% when Some with (summary) %}<p class="mt-7 text-xl italic leading-relaxed text-ink-2">{{ summary }}</p>{% when None %}{% endmatch %}{% match social_line %}{% when Some with (social) %}<p class="mt-4 font-sans text-sm text-muted">{{ social }}</p>{% when None %}{% endmatch %}{% if excerpt_only %}<p class="notice mt-6">Excerpt only — continue reading at the original site.</p>{% endif %}</header>
-  <div class="prose-body mt-10 border-t border-rule pt-8">{{ body_html|safe }}</div>
+  {% include "_article_head.html" %}
  {% match discussion_html %}{% when Some with (discussion) %}<section class="discussion prose-body mt-12 border-t border-rule pt-6 [&_.comment-meta]:font-sans [&_.comment-meta]:text-sm [&_.comment-meta]:text-muted [&_blockquote.reply]:ml-6"><h2 class="mb-6 border-0 pt-0 text-2xl">Discussion</h2>{{ discussion|safe }}</section>{% when None %}{% endmatch %}
-  <footer class="mt-12 border-t border-rule pt-6">{% match rating %}{% when Some with (widget) %}{% include "_rating_widget.html" %}{% when None %}{% endmatch %}<p class="mt-6 flex flex-wrap gap-2"><a class="btn" href="{{ read_online_url }}">Read online ↗</a>{% if page.is_admin() %}<a class="btn" href="{{ dashboard_href }}">Dashboard</a>{% endif %}</p><nav class="mt-10 grid grid-cols-1 gap-3 font-sans sm:grid-cols-2" aria-label="Adjacent articles">{% match previous %}{% when Some with (previous) %}<a class="group min-h-24 border border-rule p-4 text-ink no-underline hover:border-accent" rel="prev" href="{{ previous.href }}"><span class="block text-[0.68rem] uppercase tracking-[0.12em] text-muted">Previous</span><span class="mt-2 block leading-snug group-hover:text-accent">← {{ previous.title }}</span></a>{% when None %}{% endmatch %}{% match next %}{% when Some with (next) %}<a class="group min-h-24 border border-rule p-4 text-right text-ink no-underline hover:border-accent sm:col-start-2" rel="next" href="{{ next.href }}"><span class="block text-[0.68rem] uppercase tracking-[0.12em] text-muted">Next</span><span class="mt-2 block leading-snug group-hover:text-accent">{{ next.title }} →</span></a>{% when None %}{% endmatch %}</nav><p class="mt-8 font-sans text-sm"><a href="{{ issue_href }}">← Back to this issue</a></p></footer>
+  {% include "_related.html" %}
+  <footer class="mt-12 border-t border-rule pt-6">{% match rating %}{% when Some with (widget) %}{% include "_rating_widget.html" %}{% when None %}{% endmatch %}<p class="mt-6 flex flex-wrap gap-2"><a class="btn" href="{{ head.read_online_url }}">Read online ↗</a>{% if page.is_admin() %}<a class="btn" href="{{ head.dashboard_href }}">Dashboard</a>{% endif %}</p><nav class="mt-10 grid grid-cols-1 gap-3 font-sans sm:grid-cols-2" aria-label="Adjacent articles">{% match previous %}{% when Some with (previous) %}<a class="group min-h-24 border border-rule p-4 text-ink no-underline hover:border-accent" rel="prev" href="{{ previous.href }}"><span class="block text-[0.68rem] uppercase tracking-[0.12em] text-muted">Previous</span><span class="mt-2 block leading-snug group-hover:text-accent">← {{ previous.title }}</span></a>{% when None %}{% endmatch %}{% match next %}{% when Some with (next) %}<a class="group min-h-24 border border-rule p-4 text-right text-ink no-underline hover:border-accent sm:col-start-2" rel="next" href="{{ next.href }}"><span class="block text-[0.68rem] uppercase tracking-[0.12em] text-muted">Next</span><span class="mt-2 block leading-snug group-hover:text-accent">{{ next.title }} →</span></a>{% when None %}{% endmatch %}</nav><p class="mt-8 font-sans text-sm"><a href="{{ issue_href }}">← Back to this issue</a></p></footer>
 </article>
 </div>{% endblock %}
@@ -0,0 +1,5 @@
+{% extends "layout.html" %}{% block ears %}Article{% endblock %}{% block content %}
+<article class="reader-page mx-auto mt-10 w-full max-w-[68ch] px-4 sm:px-6 lg:mt-12 lg:px-0">
+  {% include "_article_head.html" %}
+  <footer class="mt-12 border-t border-rule pt-6"><p class="flex flex-wrap gap-2"><a class="btn" href="{{ head.read_online_url }}">Read online ↗</a>{% if page.is_admin() %}<a class="btn" href="{{ head.dashboard_href }}">Dashboard</a>{% endif %}</p></footer>
+</article>{% endblock %}
@@ -43,22 +43,21 @@

 <h2>Run history</h2>
 {% if history.is_empty() %}<p class="muted text-sm">Never considered by a run.</p>{% else %}<div class="scroll-x"><table class="history">
-<thead><tr><th>run</th><th>date</th><th>stage</th><th>reason</th><th>admitted by</th><th class="num">utility</th><th class="num">rank</th><th class="num">cluster</th><th>editor</th></tr></thead>
+<thead><tr><th>run</th><th>date</th><th>stage</th><th>reason</th><th>admitted by</th><th class="num">utility</th><th class="num">rank</th><th class="num">cluster</th></tr></thead>
 <tbody>{% for row in history %}<tr>
 <td class="cell-wrap"><details class="signals"><summary><a href="{{ row.run_href }}">run {{ row.run_id }}</a> <span class="badge {{ row.status }}">{{ row.status }}</span></summary>{% let signals = row.signals %}{% include "_signals_table.html" %}</details></td>
 <td class="cell-tight text-muted">{{ row.date }}</td>
-<td class="cell-tight"><span class="badge {{ row.stage }}">{{ row.stage }}</span></td>
-<td class="cell-tight text-muted">{% if let Some(reason) = row.reason %}{{ reason }}{% endif %}</td>
-<td class="cell-tight text-muted">{% if let Some(first) = row.admitted_first %}{{ first }}{% if !row.admitted_rest.is_empty() %} <span class="muted text-xs">({{ row.admitted_rest }})</span>{% endif %}{% endif %}</td>
+<td><span class="badge {{ row.stage }}">{{ row.stage }}</span></td>
+<td class="text-muted">{% if let Some(reason) = row.reason %}{{ reason }}{% endif %}</td>
+<td class="text-muted">{% if let Some(first) = row.admitted_first %}{{ first }}{% if !row.admitted_rest.is_empty() %} <span class="muted text-xs">({{ row.admitted_rest }})</span>{% endif %}{% endif %}</td>
 <td class="num">{{ row.utility }}</td>
 <td class="num">{{ row.rank }}</td>
 <td class="num">{{ row.cluster }}</td>
-<td class="cell-wrap text-muted">{% if let Some(why) = row.editor_why %}{{ why }}{% endif %}</td>
 </tr>{% endfor %}</tbody></table></div>{% endif %}

 <h2>Neighbours and interests</h2>
 {% if let Some(signals) = latest_signals %}{% if signals.top_interests.is_empty() && signals.neighbours.is_empty() %}<p class="muted text-sm">The latest run recorded no interests or neighbours for this article.</p>{% else %}<div class="cards">
-<section class="card"><h3>Top interests</h3>{% if signals.top_interests.is_empty() %}<p class="muted">None.</p>{% else %}<div class="scroll-x"><table><thead><tr><th>interest</th><th class="num">z</th><th class="num">cos</th></tr></thead><tbody>{% for interest in signals.top_interests %}<tr><td><a href="{{ interest.href }}">{{ interest.name }}</a></td><td class="num">{{ interest.z }}</td><td class="num">{{ interest.cos }}</td></tr>{% endfor %}</tbody></table></div>{% endif %}</section>
+<section class="card"><h3>Top interests</h3>{% if signals.top_interests.is_empty() %}<p class="muted">None.</p>{% else %}<div class="scroll-x"><table><thead><tr><th>interest</th><th class="num">z</th><th class="num">cos</th></tr></thead><tbody>{% for interest in signals.top_interests %}<tr><td class="cell-wrap"><a href="{{ interest.href }}">{{ interest.name }}</a></td><td class="num">{{ interest.z }}</td><td class="num">{{ interest.cos }}</td></tr>{% endfor %}</tbody></table></div>{% endif %}</section>
 <section class="card"><h3>Nearest rated neighbours</h3>{% if signals.neighbours.is_empty() %}<p class="muted">None.</p>{% else %}<div class="scroll-x"><table><thead><tr><th>label</th><th class="num">cos</th><th>article</th></tr></thead><tbody>{% for neighbour in signals.neighbours %}<tr><td><span class="badge {{ neighbour.label }}">{{ neighbour.label }}</span></td><td class="num">{{ neighbour.cos }}</td><td class="cell-wrap"><a href="/dashboard/articles/{{ neighbour.article_id }}">{{ neighbour.title }}</a></td></tr>{% endfor %}</tbody></table></div>{% endif %}</section>
 </div>{% endif %}{% else %}<p class="muted text-sm">No signals recorded.</p>{% endif %}

@@ -68,9 +67,9 @@
 <tbody>{% for article in articles %}<tr>
 <td class="num">{{ article.cosine }}</td>
 <td class="cell-wrap"><a href="/dashboard/articles/{{ article.id }}">{{ article.title }}</a></td>
-<td class="cell-tight">{{ article.feed }}</td>
+<td>{{ article.feed }}</td>
 <td class="cell-tight text-muted">{{ article.first_seen }}</td>
-<td class="cell-tight">{% if let Some(rating) = article.rating %}<span class="badge {{ article.rating_class }}">{{ rating }}</span>{% else %}<span class="muted">unrated</span>{% endif %}</td>
+<td>{% if let Some(rating) = article.rating %}<span class="badge {{ article.rating_class }}">{{ rating }}</span>{% else %}<span class="muted">unrated</span>{% endif %}</td>
 </tr>{% endfor %}</tbody></table></div>{% endif %}{% else %}<p class="muted text-sm">No embedding stored — run features-backfill.</p>{% endif %}

 <h2>Embedding</h2>
@@ -81,12 +80,12 @@
 <thead><tr><th>when</th><th>label</th><th class="num">value</th><th>kind</th><th>source</th><th>user</th><th>issue</th><th>note</th></tr></thead>
 <tbody>{% for event in events %}<tr>
 <td class="cell-tight text-muted">{{ event.event_at }}</td>
-<td class="cell-tight"><span class="badge {{ event.label_class }}">{{ event.label }}</span></td>
+<td><span class="badge {{ event.label_class }}">{{ event.label }}</span></td>
 <td class="num">{{ event.value }}</td>
-<td class="cell-tight text-muted">{{ event.kind }}</td>
-<td class="cell-tight text-muted">{{ event.source }}</td>
-<td class="cell-tight">{% if let Some(user) = event.user %}{{ user }}{% else %}<span class="muted">—</span>{% endif %}</td>
+<td class="text-muted">{{ event.kind }}</td>
+<td class="text-muted">{{ event.source }}</td>
+<td>{% if let Some(user) = event.user %}{{ user }}{% else %}<span class="muted">—</span>{% endif %}</td>
 <td class="cell-tight">{% if let Some(date) = event.issue_date %}<a href="/issues/{{ date }}">{{ date }}</a>{% endif %}</td>
-<td class="cell-wrap text-muted">{% if let Some(note) = event.note %}{{ note }}{% endif %}</td>
+<td class="cell-wrap text-muted">{% if let Some(note) = event.note %}<div class="line-clamp-3" title="{{ note }}">{{ note }}</div>{% endif %}</td>
 </tr>{% endfor %}</tbody></table></div>{% endif %}
 </section>{% endblock %}
@@ -18,21 +18,21 @@
 <div class="filter-actions"><button class="btn" type="submit">Apply</button> <a class="btn-quiet" href="/dashboard/articles">Reset</a></div>
 </form>
 {% include "dashboard/_pager.html" %}
-{% if articles.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table class="articles" data-filter>
+{% if articles.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table class="articles" data-filter>
 <thead><tr><th>first seen</th><th>title</th><th>feed</th><th>interests</th><th class="num">words</th><th>last stage</th><th>reason</th><th class="num">utility</th><th class="num">triage</th><th class="num">quality</th><th class="num">fit</th><th>rating</th><th>published</th></tr></thead>
 <tbody>{% for article in articles %}<tr>
 <td class="cell-tight text-muted">{{ article.first_seen }}</td>
 <td class="cell-wrap"><a href="{{ article.href }}">{{ article.title }}</a></td>
-<td class="cell-tight">{% if let Some(feed_id) = article.feed_id %}<a href="/dashboard/articles?feed={{ feed_id }}">{{ article.feed }}</a>{% else %}{{ article.feed }}{% endif %}</td>
-<td class="cell-wrap">{% for interest in article.interests %}<a class="badge" href="{{ interest.href }}">{{ interest.name }}</a>{% if !loop.last %} {% endif %}{% endfor %}</td>
+<td>{% if let Some(feed_id) = article.feed_id %}<a href="/dashboard/articles?feed={{ feed_id }}">{{ article.feed }}</a>{% else %}{{ article.feed }}{% endif %}</td>
+<td>{% for interest in article.interests %}<a class="badge" href="{{ interest.href }}">{{ interest.name }}</a>{% if !loop.last %} {% endif %}{% endfor %}</td>
 <td class="num">{{ article.words }}</td>
-<td class="cell-tight">{% if let Some(stage) = article.stage %}<span class="badge {{ stage }}">{{ stage }}</span>{% if let Some(run_id) = article.run_id %} <a class="muted text-xs" href="/dashboard/runs/{{ run_id }}">{% if let Some(date) = article.run_date %}{{ date }}{% else %}run {{ run_id }}{% endif %}</a>{% endif %}{% else %}<span class="muted text-xs">never considered</span>{% endif %}</td>
-<td class="cell-tight text-muted">{% if let Some(reason) = article.reason %}{{ reason }}{% endif %}</td>
+<td>{% if let Some(stage) = article.stage %}<span class="badge {{ stage }}">{{ stage }}</span>{% if let Some(run_id) = article.run_id %} <a class="muted text-xs" href="/dashboard/runs/{{ run_id }}">{% if let Some(date) = article.run_date %}{{ date }}{% else %}run {{ run_id }}{% endif %}</a>{% endif %}{% else %}<span class="muted text-xs">never considered</span>{% endif %}</td>
+<td class="text-muted">{% if let Some(reason) = article.reason %}{{ reason }}{% endif %}</td>
 <td class="num">{{ article.utility }}</td>
 <td class="num">{{ article.triage }}</td>
 <td class="num">{{ article.quality }}</td>
 <td class="num">{{ article.fit }}</td>
-<td class="cell-tight">{% if let Some(rating) = article.rating %}<span class="badge {{ article.rating_class }}">{{ rating }}</span>{% endif %}</td>
+<td>{% if let Some(rating) = article.rating %}<span class="badge {{ article.rating_class }}">{{ rating }}</span>{% endif %}</td>
 <td class="cell-tight">{% if let Some(date) = article.published %}<a href="/issues/{{ date }}">{{ date }}</a>{% endif %}</td>
 </tr>{% endfor %}{% if articles.is_empty() %}<tr><td colspan="13" class="text-muted">No articles match this filter.</td></tr>{% endif %}</tbody></table></div>
 {% include "dashboard/_pager.html" %}
@@ -6,7 +6,7 @@
 <nav class="tabs" aria-label="Candidate status"><a href="/dashboard/feeds"{% if status == "candidate" %} class="active" aria-current="page"{% endif %}>Candidates ({{ candidate_count }})</a> <a href="/dashboard/feeds?status=added"{% if status == "added" %} class="active" aria-current="page"{% endif %}>Added ({{ added_count }})</a> <a href="/dashboard/feeds?status=dismissed"{% if status == "dismissed" %} class="active" aria-current="page"{% endif %}>Dismissed ({{ dismissed_count }})</a></nav>
 {% if let Some(error) = categories_error %}<p class="notice">{{ error }}</p>{% endif %}
 {% include "dashboard/_pager.html" %}
-<div class="scroll-x"><table class="table-fixed">
+<div class="scroll-x"><table>
 <thead><tr><th class="num w-14">Score</th><th>Feed</th><th>Why</th><th class="num w-20">Articles</th><th class="w-20">Seen</th><th class="w-60 lg:w-84"><span class="sr-only">Actions</span></th></tr></thead>
 <tbody>{% for row in rows %}<tr>
 <td class="num tabular-nums">{{ row.score }}</td>
@@ -16,11 +16,11 @@
 <div class="filter-actions"><button class="btn" type="submit">Apply</button> <a class="btn-quiet" href="/dashboard/interests">Reset</a></div>
 </form>
 {% if rows.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter interests" aria-label="Filter interests" data-table-filter>{% endif %}
-<div class="scroll-x tall"><table data-filter>
+<div class="scroll-x"><table data-filter>
 <thead><tr><th>interest</th><th>category</th><th class="num">weight</th><th class="num">up</th><th class="num">down</th><th class="num">rated matches</th><th class="num">matched articles</th><th>added</th><th>actions</th></tr></thead>
 <tbody>{% for row in rows %}<tr>
 <td class="cell-wrap"><a href="{{ row.href }}">{{ row.name }}</a></td>
-<td class="cell-tight">{% if let Some(category) = row.category %}<a href="{{ row.category_href }}">{{ category }}</a>{% else %}<a class="muted" href="{{ row.category_href }}">uncategorized</a>{% endif %}</td>
+<td>{% if let Some(category) = row.category %}<a href="{{ row.category_href }}">{{ category }}</a>{% else %}<a class="muted" href="{{ row.category_href }}">uncategorized</a>{% endif %}</td>
 <td class="num tabular-nums">{{ row.weight }}</td>
 <td class="num tabular-nums">{{ row.up }}</td>
 <td class="num tabular-nums">{{ row.down }}</td>
@@ -17,18 +17,18 @@
 </form>
 </section>{% endfor %}</div>
 <h2>History</h2>
-{% if jobs.is_empty() %}<p class="muted text-sm">No jobs recorded yet.</p>{% else %}{% if jobs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table data-filter>
+{% if jobs.is_empty() %}<p class="muted text-sm">No jobs recorded yet.</p>{% else %}{% if jobs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table data-filter>
 <thead><tr><th class="num">job</th><th>name</th><th>requested by</th><th>requested</th><th>started</th><th>finished</th><th class="num">duration</th><th>status</th><th>message</th><th class="num">run</th></tr></thead>
 <tbody>{% for job in jobs %}<tr>
 <td class="num"><a href="/dashboard/jobs/{{ job.id }}">{{ job.id }}</a></td>
-<td class="cell-tight font-mono text-xs">{{ job.name }}</td>
-<td class="cell-tight text-muted">{{ job.requested_by }}</td>
+<td class="font-mono text-xs">{{ job.name }}</td>
+<td class="text-muted">{{ job.requested_by }}</td>
 <td class="cell-tight text-muted">{{ job.requested }}</td>
 <td class="cell-tight text-muted">{{ job.started }}</td>
 <td class="cell-tight text-muted">{{ job.finished }}</td>
 <td class="num">{{ job.duration }}</td>
-<td class="cell-tight"><span class="badge {{ job.status }}">{{ job.status }}</span></td>
-<td class="message cell-wrap text-muted">{% if let Some(message) = job.message %}{{ message }}{% endif %}</td>
+<td><span class="badge {{ job.status }}">{{ job.status }}</span></td>
+<td class="message cell-wrap text-muted">{% if let Some(message) = job.message %}<div class="line-clamp-3" title="{{ message }}">{{ message }}</div>{% endif %}</td>
 <td class="num">{% if let Some(run_id) = job.run_id %}<a href="/dashboard/runs/{{ run_id }}">{{ run_id }}</a>{% endif %}</td>
 </tr>{% endfor %}</tbody></table></div>{% endif %}
 </section>{% endblock %}
@@ -30,10 +30,10 @@
 <tbody>{% for version in versions %}<tr>
 <td class="num">#{{ version.id }}</td>
 <td class="cell-tight text-muted">{{ version.saved_at }}</td>
-<td class="cell-tight">{{ version.saved_by }}</td>
+<td>{{ version.saved_by }}</td>
 <td class="num text-muted">{{ version.bytes }} bytes</td>
-<td><pre class="preview">{{ version.preview }}</pre></td>
-<td class="cell-tight"><form method="post" action="/dashboard/profile/restore" data-confirm="Restore version #{{ version.id }}? The current file is kept as a new version."><input type="hidden" name="version_id" value="{{ version.id }}"><button class="btn" type="submit">Restore</button></form></td>
+<td class="cell-wrap"><pre class="preview">{{ version.preview }}</pre></td>
+<td><form method="post" action="/dashboard/profile/restore" data-confirm="Restore version #{{ version.id }}? The current file is kept as a new version."><input type="hidden" name="version_id" value="{{ version.id }}"><button class="btn" type="submit">Restore</button></form></td>
 </tr>{% endfor %}</tbody></table></div>
 {% endif %}

@@ -19,9 +19,9 @@
 <tbody>{% for row in imports %}<tr>
 <td class="cell-tight text-muted">{{ row.requested }}</td>
 <td class="cell-wrap"><a href="{{ row.url }}" rel="noopener" target="_blank">{{ row.url }}</a></td>
-<td class="cell-tight"><span class="badge {{ row.label }}">{{ row.verdict }}</span></td>
-<td class="cell-tight"><span class="badge {{ row.status }}">{{ row.status }}</span></td>
-<td class="cell-wrap text-muted">{{ row.message }}</td>
+<td><span class="badge {{ row.label }}">{{ row.verdict }}</span></td>
+<td><span class="badge {{ row.status }}">{{ row.status }}</span></td>
+<td class="cell-wrap text-muted"><div class="line-clamp-3" title="{{ row.message }}">{{ row.message }}</div></td>
 <td class="num">{% if let Some(article_id) = row.article_id %}<a href="/dashboard/articles/{{ article_id }}">{{ article_id }}</a>{% endif %}</td>
 </tr>{% endfor %}
 {% if imports.is_empty() %}<tr><td colspan="6" class="text-muted">No rating imports yet.</td></tr>{% endif %}</tbody>
@@ -55,19 +55,19 @@
 <div class="filter-actions"><button class="btn" type="submit">Filter</button> <a class="btn-quiet" href="{{ events_href }}">Reset</a></div>
 </form>
 <p class="meta text-sm">{{ pagination.total }} events, newest first. History is append-only; a later explicit event for the same article marks the earlier one <em>superseded</em>. Use the clear verdict to retract.</p>
-<div class="scroll-x tall"><table>
+<div class="scroll-x"><table>
 <thead><tr><th class="num">Event</th><th>Verdict</th><th class="num">Value</th><th>Article</th><th>Issue</th><th>When</th><th>Source</th><th>By</th><th>Note</th></tr></thead>
 <tbody>
 {% for event in events %}<tr{% if event.superseded %} class="superseded"{% endif %}>
 <td class="num">#{{ event.id }}{% if event.kind != "explicit" %} <span class="badge">{{ event.kind }}</span>{% endif %}{% if event.superseded %} <span class="badge cleared">superseded</span>{% endif %}</td>
-<td class="cell-tight"><span class="badge {{ event.badge }}">{{ event.verdict }}</span></td>
+<td><span class="badge {{ event.badge }}">{{ event.verdict }}</span></td>
 <td class="num">{{ event.value }}</td>
 <td class="cell-wrap"><a href="/dashboard/articles/{{ event.article_id }}">{{ event.title }}</a></td>
 <td class="cell-tight">{% if !event.issue_date.is_empty() %}<a href="/issues/{{ event.issue_date }}">{{ event.issue_date }}</a>{% endif %}</td>
 <td class="cell-tight text-muted">{{ event.when }}</td>
-<td class="cell-tight text-muted">{{ event.source }}</td>
-<td class="cell-tight text-muted">{{ event.username }}</td>
-<td class="cell-wrap text-muted">{{ event.note }}</td>
+<td class="text-muted">{{ event.source }}</td>
+<td class="text-muted">{{ event.username }}</td>
+<td class="cell-wrap text-muted"><div class="line-clamp-3" title="{{ event.note }}">{{ event.note }}</div></td>
 </tr>
 {% endfor %}
 {% if events.is_empty() %}<tr><td colspan="9" class="text-muted">No rating events match.</td></tr>{% endif %}
@@ -83,20 +83,20 @@
 <div class="filter-actions"><button class="btn" type="submit">Filter</button> <a class="btn-quiet" href="{{ current_href }}">Reset</a></div>
 </form>
 <p class="meta text-sm">One row per rated article (its latest explicit event), newest first. {% match last_run %}{% when Some with (run) %}"Used last run" counts the candidates of run #{{ run.id }} ({{ run.date }}, {{ run.status }}) that listed the article among their nearest rated neighbours, and how many of those were selected.{% when None %}No run has happened yet, so "Used last run" is empty.{% endmatch %}</p>
-<div class="scroll-x tall"><table class="contributions">
+<div class="scroll-x"><table class="contributions">
 <thead><tr><th>Verdict</th><th>Article</th><th>When · by</th><th>Note</th><th>Age → decay</th><th class="num">Neighbour weight</th><th>Feed credit</th><th>In prompt</th><th>In rebuild</th><th>Used last run</th></tr></thead>
 <tbody>
 {% for row in current %}<tr>
 <td class="rating-cell min-w-[13rem]">{% let widget = row.widget %}{% include "_rating_widget.html" %}</td>
 <td class="cell-wrap"><a href="/dashboard/articles/{{ row.article_id }}">{{ row.title }}</a><br><span class="meta text-xs">{{ row.feed_title }}{% if !row.issue_date.is_empty() %} · <a href="/issues/{{ row.issue_date }}">{{ row.issue_date }}</a>{% endif %}</span></td>
 <td class="cell-tight">{{ row.when }}<br><span class="meta text-xs">{{ row.source }} · <span class="by">{{ row.username }}</span></span></td>
-<td class="cell-wrap text-muted">{{ row.note }}</td>
+<td class="cell-wrap text-muted"><div class="line-clamp-3" title="{{ row.note }}">{{ row.note }}</div></td>
 <td class="cell-tight tabular-nums">{{ row.age_days }} d → {{ row.decay }}</td>
 <td class="num">{% if row.has_embedding && !row.neighbour_weight.is_empty() %}{{ row.neighbour_weight }}{% if row.beyond_lookback %} <span class="meta text-xs">(beyond lookback)</span>{% endif %}{% else if row.badge == "cleared" %}<span class="meta">—</span>{% else %}<span class="meta text-xs">no embedding</span>{% endif %}</td>
-<td class="cell-tight text-muted">{% for credit in row.feed_credits %}{{ credit.title }} <span class="tabular-nums text-ink">{{ credit.credit }}</span>{% if !loop.last %}<br>{% endif %}{% endfor %}</td>
+<td class="cell-wrap text-muted">{% for credit in row.feed_credits %}{{ credit.title }} <span class="tabular-nums text-ink">{{ credit.credit }}</span>{% if !loop.last %}<br>{% endif %}{% endfor %}</td>
 <td class="text-center">{% if row.in_prompt %}<span class="text-loved">✓</span>{% endif %}</td>
 <td class="text-center">{% if row.in_rebuild %}<span class="text-loved">✓</span>{% endif %}</td>
-<td class="cell-tight tabular-nums">{% if row.used_total > 0 %}{{ row.used_total }} ({{ row.used_selected }} selected){% endif %}</td>
+<td class="tabular-nums">{% if row.used_total > 0 %}{{ row.used_total }} ({{ row.used_selected }} selected){% endif %}</td>
 </tr>
 {% endfor %}
 {% if current.is_empty() %}<tr><td colspan="10" class="text-muted">No current verdicts match.</td></tr>{% endif %}
@@ -17,7 +17,7 @@
 <div class="scroll-x"><table class="funnel-table">
 <thead><tr><th>stage</th><th>share</th><th class="num">reached</th><th class="num">stopped here</th><th>why</th></tr></thead>
 <tbody>{% for stage in funnel %}<tr>
-<td class="cell-tight align-middle"><span class="badge {{ stage.stage }}">{{ stage.stage }}</span></td>
+<td class="align-middle"><span class="badge {{ stage.stage }}">{{ stage.stage }}</span></td>
 <td class="funnel-cell"><div class="funnel"><svg class="h-3" width="{{ stage.percent }}%" role="img" aria-label="{{ stage.reached }} reached"></svg></div></td>
 <td class="num align-middle">{{ stage.reached }}</td>
 <td class="num align-middle text-muted">{{ stage.stopped }}</td>
@@ -45,7 +45,7 @@
 <h2>Near misses</h2>
 {% if near_misses.is_empty() %}<p class="muted text-sm">None recorded.</p>{% else %}<div class="scroll-x"><table>
 <thead><tr><th class="num">#</th><th class="num">score</th><th>title</th><th>feed</th><th class="num">quality</th><th class="num">fit</th><th>stage</th><th>reason</th></tr></thead>
-<tbody>{% for miss in near_misses %}<tr><td class="num text-muted">{{ loop.index }}</td><td class="num">{{ miss.score }}</td><td class="cell-wrap"><a href="{{ miss.href }}">{{ miss.title }}</a></td><td class="cell-tight text-muted">{{ miss.feed }}</td><td class="num">{{ miss.quality }}</td><td class="num">{{ miss.fit }}</td><td class="cell-tight"><span class="badge {{ miss.stage }}">{{ miss.stage }}</span></td><td class="cell-wrap text-muted">{% if let Some(reason) = miss.reason %}{{ reason }}{% endif %}</td></tr>{% endfor %}</tbody></table></div>{% endif %}
+<tbody>{% for miss in near_misses %}<tr><td class="num text-muted">{{ loop.index }}</td><td class="num">{{ miss.score }}</td><td class="cell-wrap"><a href="{{ miss.href }}">{{ miss.title }}</a></td><td class="text-muted">{{ miss.feed }}</td><td class="num">{{ miss.quality }}</td><td class="num">{{ miss.fit }}</td><td><span class="badge {{ miss.stage }}">{{ miss.stage }}</span></td><td class="cell-wrap text-muted">{% if let Some(reason) = miss.reason %}{{ reason }}{% endif %}</td></tr>{% endfor %}</tbody></table></div>{% endif %}

 <h2>Candidates</h2>
 <form class="filters" method="get" action="/dashboard/runs/{{ run.id }}">
@@ -58,8 +58,8 @@
 <div class="filter-actions"><button class="btn" type="submit">Apply</button> <a class="btn-quiet" href="/dashboard/runs/{{ run.id }}">Reset</a></div>
 </form>
 {% include "dashboard/_pager.html" %}
-{% if candidates.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table class="candidates" data-filter>
-<thead><tr><th>title</th><th>feed</th><th class="num">words</th><th>stage</th><th>reason</th><th>admitted by</th><th class="num">utility</th><th class="num">rank</th><th class="num">cluster</th><th class="num">triage</th><th class="num">quality</th><th class="num">fit</th><th>flags</th><th>editor</th></tr></thead>
-<tbody>{% for candidate in candidates %}{% include "_candidate_row.html" %}{% endfor %}{% if candidates.is_empty() %}<tr><td colspan="14" class="text-muted">No candidates match this filter.</td></tr>{% endif %}</tbody></table></div>
+{% if candidates.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table class="candidates" data-filter>
+<thead><tr><th>title</th><th>feed</th><th class="num">words</th><th>stage</th><th>reason</th><th>admitted by</th><th class="num">utility</th><th class="num">rank</th><th class="num">cluster</th><th class="num">triage</th><th class="num">quality</th><th class="num">fit</th><th>flags</th></tr></thead>
+<tbody>{% for candidate in candidates %}{% include "_candidate_row.html" %}{% endfor %}{% if candidates.is_empty() %}<tr><td colspan="13" class="text-muted">No candidates match this filter.</td></tr>{% endif %}</tbody></table></div>
 {% include "dashboard/_pager.html" %}
 </section>{% endblock %}
@@ -7,12 +7,12 @@
 <label>Status <select name="status"><option value="">any</option>{% for name in statuses %}<option value="{{ name }}"{% if status == *name %} selected{% endif %}>{{ name }}</option>{% endfor %}</select></label>
 <div class="filter-actions"><button class="btn" type="submit">Filter</button>{% if !status.is_empty() %}<a class="btn-quiet" href="/dashboard/runs">Reset</a>{% endif %}</div>
 </form>
-{% if runs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table data-filter>
+{% if runs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table data-filter>
 <thead><tr><th>run</th><th>date</th><th>status</th><th>started</th><th>duration</th><th>considered → eligible → triaged → assessed → shortlisted → selected</th><th>cost</th><th class="num">total</th><th class="num">warnings</th></tr></thead>
 <tbody>{% for run in runs %}<tr>
 <td class="num"><a href="/dashboard/runs/{{ run.id }}">{{ run.id }}</a></td>
 <td class="cell-tight"><a href="/issues/{{ run.date }}">{{ run.date }}</a></td>
-<td class="cell-tight"><span class="badge {{ run.status }}">{{ run.status }}</span>{% if run.dry_run %} <span class="muted text-xs">dry</span>{% endif %}</td>
+<td><span class="badge {{ run.status }}">{{ run.status }}</span>{% if run.dry_run %} <span class="muted text-xs">dry</span>{% endif %}</td>
 <td class="cell-tight text-muted">{{ run.started }}</td>
 <td class="num text-muted">{{ run.duration }}</td>
 <td class="cell-tight tabular-nums">{{ run.funnel }}</td>
@@ -3,11 +3,11 @@
 <h1>Settings history</h1>
 <p class="page-desc">Every settings change made through the dashboard, newest first. Hand edits to <code>config.toml</code> on disk are not recorded here.</p>
 </div><div class="page-actions"><a class="btn" href="/dashboard/settings">Back to settings</a></div></header>
-{% if changes.is_empty() %}<p class="muted text-sm">No settings have been changed through the dashboard yet.</p>{% else %}{% if changes.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table class="history" data-filter>
+{% if changes.is_empty() %}<p class="muted text-sm">No settings have been changed through the dashboard yet.</p>{% else %}{% if changes.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table class="history" data-filter>
 <thead><tr><th>When</th><th>Who</th><th>Key</th><th>Before</th><th>After</th></tr></thead>
 <tbody>{% for change in changes %}<tr>
 <td class="cell-tight text-muted">{{ change.changed_at }}</td>
-<td class="cell-tight">{% match change.username %}{% when Some with (name) %}{{ name }}{% when None %}<em class="text-muted">removed user</em>{% endmatch %}</td>
+<td>{% match change.username %}{% when Some with (name) %}{{ name }}{% when None %}<em class="text-muted">removed user</em>{% endmatch %}</td>
 <td><code>{{ change.key }}</code></td>
 <td class="cell-wrap">{% match change.old_value %}{% when Some with (value) %}<pre class="preview">{{ value }}</pre>{% when None %}<em class="text-muted">absent</em>{% endmatch %}</td>
 <td class="cell-wrap">{% match change.new_value %}{% when Some with (value) %}<pre class="preview">{{ value }}</pre>{% when None %}<em class="text-muted">removed</em>{% endmatch %}</td>
@@ -27,14 +27,14 @@
 </div>

 <h2>Spend by day</h2>
-{% if cost_rows.is_empty() %}<p class="muted text-sm">No provider costs recorded in the window.</p>{% else %}{% if cost_rows.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table data-filter>
+{% if cost_rows.is_empty() %}<p class="muted text-sm">No provider costs recorded in the window.</p>{% else %}{% if cost_rows.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table data-filter>
 <thead><tr><th>day (UTC)</th>{% for provider in providers %}<th class="num">{{ provider }}</th>{% endfor %}<th class="num">total</th></tr></thead>
 <tbody>{% for row in cost_rows %}<tr><td class="cell-tight">{{ row.date }}</td>{% for cell in row.cells %}<td class="num text-muted">{{ cell }}</td>{% endfor %}<td class="num">{{ row.total }}</td></tr>{% endfor %}</tbody></table></div>{% endif %}

 <h2>Runs in the window</h2>
-{% if runs.is_empty() %}<p class="muted text-sm">No finished runs in the window.</p>{% else %}{% if runs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table data-filter>
+{% if runs.is_empty() %}<p class="muted text-sm">No finished runs in the window.</p>{% else %}{% if runs.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table data-filter>
 <thead><tr><th class="num">run</th><th>date</th><th>status</th><th class="num">cost</th><th class="num">selected</th><th class="num">duration</th></tr></thead>
-<tbody>{% for run in runs %}<tr><td class="num"><a href="/dashboard/runs/{{ run.run_id }}">{{ run.run_id }}</a></td><td class="cell-tight"><a href="/issues/{{ run.date }}">{{ run.date }}</a></td><td class="cell-tight"><span class="badge {{ run.status }}">{{ run.status }}</span></td><td class="num">{{ run.cost }}</td><td class="num">{{ run.selected }}</td><td class="num text-muted">{{ run.duration }}</td></tr>{% endfor %}</tbody></table></div>{% endif %}
+<tbody>{% for run in runs %}<tr><td class="num"><a href="/dashboard/runs/{{ run.run_id }}">{{ run.run_id }}</a></td><td class="cell-tight"><a href="/issues/{{ run.date }}">{{ run.date }}</a></td><td><span class="badge {{ run.status }}">{{ run.status }}</span></td><td class="num">{{ run.cost }}</td><td class="num">{{ run.selected }}</td><td class="num text-muted">{{ run.duration }}</td></tr>{% endfor %}</tbody></table></div>{% endif %}

 <details class="explain disclosure" id="stats-text"><summary>As text (<code>daily-epub stats --days {{ days }}</code>)</summary><div class="disclosure-body"><pre class="preview">{{ text }}</pre></div></details>
 </section>{% endblock %}
@@ -15,7 +15,7 @@
 <td><div class="flex flex-wrap gap-2"><form class="form-inline" method="post" action="/dashboard/users/requests/{{ request.id }}/approve"><input type="text" name="username" value="{{ request.suggested_username }}" autocomplete="username" maxlength="32" required pattern="[A-Za-z0-9._-]+" aria-label="Username for {{ request.email }}"><button class="btn-primary" type="submit"{% if !mail_configured %} disabled title="Email is not configured"{% endif %}>Approve</button></form><form method="post" action="/dashboard/users/requests/{{ request.id }}/done"><button class="btn" type="submit">Mark done</button></form></div></td>
 </tr>{% endfor %}</tbody></table></div>{% endif %}
 </section>
-{% if users.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x tall"><table data-filter>
+{% if users.len() > 1 %}<input type="search" class="table-filter" placeholder="Filter rows on this page" aria-label="Filter rows on this page" data-table-filter>{% endif %}<div class="scroll-x"><table data-filter>
 <thead><tr><th>Username</th><th>Role</th><th>Status</th><th>Created</th><th>Last login</th><th class="num">Open sessions</th></tr></thead>
 <tbody>{% for user in users %}<tr>
 <td class="font-medium text-ink">{{ user.username }}</td>
@@ -1 +1 @@
-{% for section in issue.sections %}<h2>{{ section.name }}</h2><ul>{% for entry in section.entries %}<li><a href="{{ entry.url }}">{{ entry.title }}</a> — {% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{{ entry.source }}{% match entry.publication %}{% when Some with (publication) %} · {{ publication }}{% when None %}{% endmatch %}{% match entry.summary %}{% when Some with (summary) %}<p class="summary">{{ summary }}</p>{% when None %}{% endmatch %}{% match entry.why %}{% when Some with (why) %}<p class="why"><em>Why it's here: {{ why }}</em></p>{% when None %}{% endmatch %}{% if !entry.comment_links.is_empty() %} · {% for link in entry.comment_links %}<a href="{{ link.url }}">{{ link.label }}</a>{% endfor %}{% endif %}</li>{% endfor %}</ul>{% endfor %}
+{% for section in issue.sections %}<h2>{{ section.name }}</h2><ul>{% for entry in section.entries %}<li><a href="{{ entry.url }}">{{ entry.title }}</a><p class="meta">{% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{{ entry.source }}{% match entry.publication %}{% when Some with (publication) %} · {{ publication }}{% when None %}{% endmatch %}</p>{% match entry.summary %}{% when Some with (summary) %}<p class="summary">{{ summary }}</p>{% when None %}{% endmatch %}{% if !entry.comment_links.is_empty() %}<p class="links">{% for link in entry.comment_links %}<a href="{{ link.url }}">{{ link.label }}</a>{% if !loop.last %} · {% endif %}{% endfor %}</p>{% endif %}</li>{% endfor %}</ul>{% endfor %}
@@ -5,7 +5,7 @@
  <section aria-labelledby="brief-heading" data-toc-entry="/issues/{{ date }}"><h1 id="brief-heading" class="reader-section-heading">The Brief</h1><div class="editorial prose-body mt-5 [&>p:first-child]:first-letter:float-left [&>p:first-child]:first-letter:mr-2 [&>p:first-child]:first-letter:mt-1 [&>p:first-child]:first-letter:font-serif [&>p:first-child]:first-letter:text-[4.6rem] [&>p:first-child]:first-letter:font-semibold [&>p:first-child]:first-letter:leading-[0.72]">{{ front_page_html|safe }}</div></section>
  {% if (page.is_admin() && read_href.is_some()) || downloads.is_some() %}<div class="my-8 flex flex-wrap gap-2 border-y border-rule py-4">{% if page.is_admin() %}{% match read_href %}{% when Some with (href) %}<a class="btn" href="{{ href }}" target="_blank" rel="noopener">Read in BookOrbit</a>{% when None %}{% endmatch %}{% endif %}{% match downloads %}{% when Some with (downloads) %}{% if downloads.others.is_empty() %}<a class="btn" href="{{ downloads.primary.href }}">Download {{ downloads.primary.label }}</a>{% else %}<div class="relative inline-flex"><a class="btn rounded-r-none" href="{{ downloads.primary.href }}">Download {{ downloads.primary.label }}</a><details class="-ml-px"><summary class="btn list-none rounded-l-none px-2 [&::-webkit-details-marker]:hidden" aria-label="Choose download format"><span aria-hidden="true">▾</span></summary><div class="absolute left-0 top-full z-20 mt-1 min-w-52 border border-rule bg-paper p-1 shadow-[0_18px_32px_-26px_rgb(0_0_0_/_0.6)]"><a class="btn group w-full justify-between border-0" href="{{ downloads.primary.href }}"><span>{% if downloads.primary.label == "EPUB" %}Standard {% endif %}{{ downloads.primary.label }}</span><span class="ml-4 text-muted group-hover:text-paper">{{ downloads.primary.size }}</span></a>{% for download in downloads.others %}<a class="btn group w-full justify-between border-0" href="{{ download.href }}"><span>{{ download.label }}</span><span class="ml-4 text-muted group-hover:text-paper">{{ download.size }}</span></a>{% endfor %}</div></details></div>{% endif %}{% when None %}{% endmatch %}</div>{% endif %}
  <section class="mt-12" aria-labelledby="index-heading"><h2 id="index-heading" class="text-center text-3xl font-semibold leading-[1.1] tracking-[-0.01em]">In This Issue</h2>
-    {% for section in sections %}<section class="mt-14"><h3 class="reader-section-heading">{{ section.name }}</h3><ul class="m-0 list-none p-0">{% for entry in section.entries %}<li class="border-b border-rule py-6" data-toc-entry="{{ entry.href }}"><h4 class="font-serif font-semibold leading-[1.1] tracking-[-0.01em] {% if entry.is_lead %}text-3xl{% else %}text-2xl{% endif %}"><a class="text-ink no-underline hover:text-accent" href="{{ entry.href }}">{{ entry.title }}</a></h4><p class="mt-2 font-sans text-sm text-muted">{% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{% let source = entry.source %}{% include "_source.html" %} · {{ entry.reading_minutes }} min read{% if page.is_admin() %} · <a class="text-muted hover:text-accent" href="{{ entry.dashboard_href }}">dashboard</a>{% endif %}</p>{% let understanding = entry.understanding %}{% let why = entry.why %}{% include "_understanding.html" %}{% if !entry.summary.is_empty() %}<p class="index-summary mt-4">{{ entry.summary }}</p>{% endif %}{% match entry.rating %}{% when Some with (widget) %}{% include "_rating_widget.html" %}{% when None %}{% endmatch %}</li>{% endfor %}</ul></section>{% endfor %}
+    {% for section in sections %}<section class="mt-14"><h3 class="reader-section-heading">{{ section.name }}</h3><ul class="m-0 list-none p-0">{% for entry in section.entries %}<li class="border-b border-rule py-6" data-toc-entry="{{ entry.href }}"><h4 class="font-serif font-semibold leading-[1.1] tracking-[-0.01em] {% if entry.is_lead %}text-3xl{% else %}text-2xl{% endif %}"><a class="text-ink no-underline hover:text-accent" href="{{ entry.href }}">{{ entry.title }}</a></h4><p class="mt-2 font-sans text-sm text-muted">{% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{% let source = entry.source %}{% include "_source.html" %} · {{ entry.reading_minutes }} min read{% if page.is_admin() %} · <a class="text-muted hover:text-accent" href="{{ entry.dashboard_href }}">dashboard</a>{% endif %}</p>{% let understanding = entry.understanding %}{% include "_understanding.html" %}{% if !entry.summary.is_empty() %}<p class="index-summary mt-4">{{ entry.summary }}</p>{% endif %}{% match entry.rating %}{% when Some with (widget) %}{% include "_rating_widget.html" %}{% when None %}{% endmatch %}</li>{% endfor %}</ul></section>{% endfor %}
  </section>
  {% if has_world || has_behind %}<nav class="my-12 flex flex-wrap items-center justify-center gap-x-3 gap-y-1 border-y border-rule py-4 text-center font-sans text-sm uppercase tracking-[0.08em]" aria-label="Issue chapters">{% if has_world %}<a class="text-ink no-underline hover:text-accent" href="/issues/{{ date }}/world">World Briefing</a>{% endif %}{% if has_world && has_behind %}<span class="text-muted" aria-hidden="true">·</span>{% endif %}{% if has_behind %}<a class="text-ink no-underline hover:text-accent" href="/issues/{{ date }}/behind">Behind the paper</a>{% endif %}</nav>{% endif %}
  <footer id="colophon" class="mt-14 scroll-mt-6 font-sans text-sm leading-relaxed" data-toc-entry="/issues/{{ date }}#colophon"><h2 class="reader-section-heading">Colophon</h2><p class="my-4 text-ink-2"><em>The Daily EPUB</em> is assembled every morning from a personal feed reader.</p><dl class="kv border-y border-rule py-4 text-xs sm:text-sm"><dt>Generated</dt><dd>{{ colophon.generated_at }}</dd><dt>Bulk model</dt><dd>{{ colophon.bulk_model }}</dd><dt>Editor model</dt><dd>{{ colophon.editor_model }}</dd><dt>Summaries model</dt><dd>{{ colophon.summaries_model }}</dd><dt>Entries considered</dt><dd>{% match colophon.entries_fetched %}{% when Some with (entries) %}{{ entries }}{% match colophon.feeds_seen %}{% when Some with (feeds) %} from {{ feeds }} feeds{% when None %}{% endmatch %}{% when None %}n/a{% endmatch %}</dd><dt>Candidates scored</dt><dd>{% match colophon.candidates %}{% when Some with (candidates) %}{{ candidates }}{% when None %}n/a{% endmatch %}</dd><dt>Articles selected</dt><dd>{{ colophon.article_count }} across {{ colophon.section_count }} sections</dd><dt>Words</dt><dd>{{ colophon.total_words }} · ~{{ colophon.reading_minutes }} min read</dd>{% for cost in colophon.provider_costs %}<dt>{{ cost.provider }} cost</dt><dd>{{ cost.cost }}</dd>{% endfor %}<dt>Total token cost</dt><dd>{% match colophon.cost_usd %}{% when Some with (cost) %}{{ cost }}{% when None %}n/a{% endmatch %}</dd><dt>Generator</dt><dd>{{ colophon.generator_version }}</dd></dl></footer>
@@ -4,6 +4,6 @@
  <header class="mb-10 text-center"><p class="font-sans text-[0.72rem] uppercase tracking-[0.12em] text-muted">{{ issue.display_date }} · No. {{ issue.issue_number }}</p><p class="mt-2 font-sans text-sm text-muted">{{ issue.stats_line }}</p><p class="mx-auto mt-5 max-w-[58ch] text-lg italic leading-relaxed text-ink-2">A personal morning paper, assembled daily; the selection is the reader's, the words are the authors'.</p></header>
  <p class="notice mb-8"><a href="/login">Sign in</a> to read every article's full text and download the editions, or <a href="/request-access">request access</a>.</p>
  {% if !downloads.is_empty() %}<div class="mb-8 flex flex-wrap justify-center gap-2">{% for download in downloads %}<a class="btn" href="{{ download.href }}">{{ download.label }} <span class="ml-1 text-muted">{{ download.size }}</span></a>{% endfor %}</div>{% endif %}
-  {% for section in issue.sections %}<section class="mt-14"><h2 class="reader-section-heading">{{ section.name }}</h2><div>{% for entry in section.entries %}<article class="border-b border-rule py-6{% if entry.is_lead %} pt-5{% endif %}"><h3 class="font-semibold leading-[1.1] tracking-[-0.01em] {% if entry.is_lead %}text-3xl{% else %}text-2xl{% endif %}"><a class="text-ink no-underline hover:text-accent" href="{{ entry.url }}">{{ entry.title }}</a></h3><p class="mt-2 font-sans text-sm leading-relaxed text-muted">{% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{{ entry.source }}{% match entry.publication %}{% when Some with (publication) %} · {{ publication }}{% when None %}{% endmatch %} · {{ entry.reading_minutes }} min</p>{% let understanding = entry.understanding %}{% let why = entry.why %}{% include "_understanding.html" %}{% match entry.summary %}{% when Some with (summary) %}<p class="index-summary mt-4">{{ summary }}</p>{% when None %}{% endmatch %}{% if !entry.comment_links.is_empty() %}<p class="mt-3 flex flex-wrap gap-x-4 gap-y-1 font-sans text-sm text-muted">{% for link in entry.comment_links %}<a class="text-muted hover:text-accent" rel="noopener" target="_blank" href="{{ link.url }}">{{ link.label }}{% if !link.meta.is_empty() %}: {{ link.meta }}{% endif %}</a>{% endfor %}</p>{% endif %}</article>{% endfor %}</div></section>{% endfor %}
+  {% for section in issue.sections %}<section class="mt-14"><h2 class="reader-section-heading">{{ section.name }}</h2><div>{% for entry in section.entries %}<article class="border-b border-rule py-6{% if entry.is_lead %} pt-5{% endif %}"><h3 class="font-semibold leading-[1.1] tracking-[-0.01em] {% if entry.is_lead %}text-3xl{% else %}text-2xl{% endif %}"><a class="text-ink no-underline hover:text-accent" href="{{ entry.url }}">{{ entry.title }}</a></h3><p class="mt-2 font-sans text-sm leading-relaxed text-muted">{% match entry.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{{ entry.source }}{% match entry.publication %}{% when Some with (publication) %} · {{ publication }}{% when None %}{% endmatch %} · {{ entry.reading_minutes }} min</p>{% let understanding = entry.understanding %}{% include "_understanding.html" %}{% match entry.summary %}{% when Some with (summary) %}<p class="index-summary mt-4">{{ summary }}</p>{% when None %}{% endmatch %}{% if !entry.comment_links.is_empty() %}<p class="mt-3 flex flex-wrap gap-x-4 gap-y-1 font-sans text-sm text-muted">{% for link in entry.comment_links %}<a class="text-muted hover:text-accent" rel="noopener" target="_blank" href="{{ link.url }}">{{ link.label }}{% if !link.meta.is_empty() %}: {{ link.meta }}{% endif %}</a>{% endfor %}</p>{% endif %}</article>{% endfor %}</div></section>{% endfor %}
  <p class="mt-10 text-center font-sans text-sm"><a href="/issues">Browse the archive →</a></p>
 {% endif %}</article>{% endblock %}
@@ -619,11 +619,6 @@ async fn llm_pipeline_runs_against_a_mock_backend() {
        "the model's summaries were used, not excerpts"
    );
    assert!(editorial_doc.front_page_html.contains("storage internals"));
-    assert!(
-        lineup.picks.iter().all(|p| p.why.is_none()),
-        "the scripted editor gave no why lines"
-    );
-
    // Every scripted response was consumed, and the meter priced them (§3.6).
    assert_eq!(backend.calls(), 1 + 1 + 5 + 1);
    let total = meter.total();
@@ -1,10 +1,10 @@
 {
  "picks": [
-    { "id": 101, "section": "Top Stories", "position": 1, "lead_story": true, "why": "The migration post-mortem with the invoices still attached" },
-    { "id": 102, "section": "Tech & Engineering", "position": 1, "lead_story": false, "why": "A failover story you'd argue with over coffee" },
-    { "id": 103, "section": "Tech & Engineering", "position": 2, "lead_story": false, "why": "Rare first-hand detail on a tool you use daily" },
-    { "id": 104, "section": "AI & Machine Learning", "position": 1, "lead_story": false, "why": "The one benchmark piece this week that shows its work" },
-    { "id": 105, "section": "Boston & Local", "position": 1, "lead_story": false, "why": "MBTA slow zones charted by a rider, not a press office" },
+    { "id": 101, "section": "Top Stories", "position": 1, "lead_story": true },
+    { "id": 102, "section": "Tech & Engineering", "position": 1, "lead_story": false },
+    { "id": 103, "section": "Tech & Engineering", "position": 2, "lead_story": false },
+    { "id": 104, "section": "AI & Machine Learning", "position": 1, "lead_story": false },
+    { "id": 105, "section": "Boston & Local", "position": 1, "lead_story": false },
    { "id": 106, "section": "Culture & Essays", "position": 1 },
    { "section": "Niche Corner", "position": 2, "lead_story": false },
    "the model sometimes trails off like this"
Author	SHA1	Message	Date
thalladaandClaude Opus 5.5	ddc98788c6	Require 80% shared title words for same-site related duplicates Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AeJmv3WED4w8S3GV7mMjS7	2026-10-12 19:26:37 +00:00
thalladaandClaude Opus 5.5	682fc4a6fb	Drop re-published copies of one story from related lists The ingest dedupe only merges within one run, so a story an outlet re-publishes on another day under a new URL and a reworded headline lands in the archive twice and both copies showed up as related links. Links now also skip an article from the same site as the pick or a closer link when 60% of their title words match, besides exact title matches anywhere. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AeJmv3WED4w8S3GV7mMjS7	2026-10-12 18:50:24 +00:00
thalladaandClaude Opus 5.5	08b15c42b4	Simplify related articles: shared article header, ids only, no job - Both article pages render one `_article_head.html` partial from an `ArticleHead` built by a single constructor instead of two copies. - `related::for_article` returns ids; the cosine stays stored for tuning. - Title keys travel with each candidate, dropping the side map. - Drop the `related-refresh` dashboard job: the backfill is a one-off and `features related` covers it. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AeJmv3WED4w8S3GV7mMjS7	2026-10-12 16:11:43 +00:00
thalladaandClaude Opus 5.5	03f0a454be	Add related articles under web issue articles and keep embeddings forever Each pick's web page now lists up to five related articles: the nearest embedded articles across the whole archive (cosine >= 0.55), excluding the rest of the issue, excerpt-only articles and same-title copies. They are computed once per issue after publishing and stored in issue_related (migration 0014), since the full embedding scan is too slow per page view; `features related [--date]` and the related-refresh job backfill older issues. Related articles that ran in an issue link to that issue page; the rest link to a new signed-in /articles/{id} page rendering the stored body with no summary. /articles/{id} for a published article redirects to its issue page. embedding_retention_days = 0 now means keep every vector (previously it would have deleted every unrated, unpublished embedding) and is the new default, so related lists can reach the whole archive. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01AeJmv3WED4w8S3GV7mMjS7	2026-10-11 21:34:31 +00:00
thalladaandClaude Opus 5.5	bf6a8d0129	Flatten X4 tables that hold images or nested tables CrossPoint and CrossInk print an image's alt text instead of drawing it inside a table cell, and CrossInk drops all text of a nested table. Layout tables (The Space Review's figures) lost every image on the X4: 59 images across 8 articles in the published issues. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 20:13:21 +00:00
thalladaandClaude Opus 5.5	7851d8e231	Add an X4 preview tool that renders pages with the real XTC converter Builds both editions around one article (a URL through real extraction, or an HTML file), runs the XTC converter on the X4 edition and decodes every page to PNG. --convert re-renders an existing EPUB, for iterating on a stylesheet. The decoder follows the converter's encoder, which writes the level's low bit to the first plane, rather than the spec's table. The device itself reads the X4 EPUB through its firmware, which lays out differently. Check those layouts with the firmware's own host tests. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 19:53:06 +00:00
thalladaandClaude Opus 5.5	5abf062c24	Add rebuild: republish an issue's EPUBs from its stored content `daily-epub rebuild --date D` (and the rebuild-YYYY-MM-DD job) takes the issues.issue_json snapshot and restores each article's body from its row. It then builds both editions and the XTC, publishes them under the same names and records the issue as a run would. Nothing is curated again or refreshed from live rows, so headlines, summaries, social lines and rating links stay as published; only images are downloaded again. It takes the run lock, opens the database without migrating, and the job is marked dangerous like generate. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 19:53:06 +00:00
thalladaandClaude Opus 5.5	9e521ddaef	Lay out X4 code blocks as one paragraph per line The X4 firmwares (CrossPoint and forks such as CrossInk) ignore white-space and treat <pre> as inline. Its margins never applied, so the paragraph after a listing started on the next line. CrossInk also glued the first code line onto the paragraph before it. The simplifier now makes each listing line a <p class="code-line">, the one path both firmwares lay out identically. The first and last lines carry the block's margins. Inline tags open across a line break are closed and reopened on the next line. A blank source line used to be a paragraph of its own. With the firmware's default paragraph spacing that read as a double newline, so blank lines now become a half-line gap (p.code-gap) on the line before. The X4 theme matches the standard one but uses only the device's exact levels (#000, #555, #aaa), so glyphs are not dithered. Inline code is display: inline for the XTC converter's CREngine. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 19:53:06 +00:00
thalladaandClaude Opus 5.5	50551114cd	Richer monochrome syntax theme and code-block layout in the standard EPUB Following zenbones and lackluster, the theme keeps what the code names in ink (functions bold, types italic) and moves the language's own syntax to grey (keywords bold grey, literals and punctuation grey). Comments are the lightest. Weight and slant carry the distinctions, so nothing depends on colour. Code blocks stay left-aligned inside a <figure>, which centres for image captions, and have explicit margins. Inline code is display: inline because CREngine readers (KOReader, PocketBook) make it a block. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 19:53:06 +00:00
thalladaandClaude Opus 5.5	13c81440ef	Seed a hinted and an unhinted code block The dev server now shows both highlighting paths: a Rust block marked by its source, and a Python block left to detection. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 02:27:23 +00:00
thalladaandClaude Opus 5.5	248038ec97	Style syntax tokens: print colours on the web, monochrome in the EPUBs The web uses ink with a few print colours: oxblood keywords, bottle-green strings, umber literals, slate types, muted italic comments. Each is defined as an --hl-* token, and all reach at least 4.5:1 on paper-2 in both themes. The EPUBs rely on weight and slant (bold keywords, grey italic comments), using flat selectors for the X4. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 02:27:23 +00:00
thalladaandClaude Opus 5.5	78fc38e99d	Highlight code blocks in article bodies arborium (tree-sitter) renders each token as a flat <span class="hl-…">, which the X4's no-descendant-selector stylesheet can still target. The sanitizer strips class attributes, so language hints never reached the database. annotate_hints now copies them onto <pre data-lang> before readability and sanitizing: pre/code classes, Rouge and GitHub wrapper divs, SyntaxHighlighter's brush:, and data-lang style attributes. ammonia keeps only canonical values. Highlighting runs at render time for the web article page and both EPUB editions, so stored articles benefit too. Unhinted blocks are guessed from content (JSON that parses, shebangs, leading <script>/<style>, then betlang at >= 0.5). A borderline block also takes the article's prevailing language when that language is among its top candidates. Anything else stays plain, since wrong colours are worse than none. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-10-01 02:27:23 +00:00
thalladaandClaude Fable 5.1	8d0516bedc	Show table-centric dashboard pages at full height Only the profile page's version history keeps the 70vh scrolling island; it has three sections below it. Everything else is paginated or last on its page, so the page itself scrolls. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 22:16:07 +00:00
thalladaandClaude Fable 5.1	e5ca78ba41	Size the wide table wrapper to its table The wrapper spanned the whole wide track while the table sat centred inside it, so the empty flanks were part of the scroll container and caught the wheel. A centred grid item is sized fit-content, so the wrapper now hugs the table; the page-column floor and viewport cap move onto the wrapper. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 22:02:36 +00:00
thalladaandClaude Fable 5.1	3c4f8de3a4	Keep the dashboard's vertical rhythm under the grid Grid items never collapse margins, so the row-filter input and the rating form pushed the next child down by their bottom margins. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 21:43:42 +00:00
thalladaandClaude Fable 5.1	dd91b83c27	Badge lists wrap on their own; note table floors in the doc Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 21:29:03 +00:00
thalladaandClaude Fable 5.1	815e7307d1	Rebuild app.css for the merged templates; keep the ratings timestamp on one line Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 21:19:07 +00:00
thallada	9af6fedbe0	Merge branch 'tables-tpl' into dashboard-tables	2026-09-20 21:13:01 +00:00
thalladaandClaude Fable 5.1	6016745297	Let dashboard tables wrap and use the whole viewport Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 21:12:22 +00:00
thalladaandClaude Fable 5.1	8a355b637f	Give every dashboard table cell a content class Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 21:08:32 +00:00
thalladaandClaude Fable 5.1	8889a4e351	Add the dashboard table framework design and Codex briefs Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>	2026-09-20 20:54:12 +00:00
thallada	0f17480be7	Tweak feed.json structuring	2026-09-19 18:53:50 +00:00
thallada	525ddfd88d	Add feed.json alternate to feed.xml Mainly so my glance web dashboard can read the feed.	2026-09-19 18:22:16 +00:00
thallada	f1b1e7fd98	Tweak styling of interest tags on web and in epubs	2026-09-17 18:50:01 +00:00
thalladaandClaude Fable 5.1	ce9b629115	Show matched interests as a tag row instead of a callout With the why line gone the accent-bar callout held nothing but "Matches: a · b", which no longer earned its quoting. Every surface now puts one row directly under the rubric: a small-caps "Matches" label and one pill chip per interest. On the web that is one `.interest-chip` component (admins still get links to the interest's article filter); the EPUB gets `.matches`/`.interest` rules in both stylesheets, and `Understanding::interests_line` goes. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01ESJbbzQ1b8fs5AA65tKw2q	2026-09-15 01:09:14 +00:00
thalladaandClaude Fable 5.1	36424784af	Drop the editor's "Why it's here" line After a rewrite of the prompt rule and a few more live issues the line still read as a second abstract, so it goes entirely: the rule and the "why" key in the editor's JSON, the parsing and 14-word cap, the Pick field, the issue_articles and candidate_runs writes, the Brief prompt's per-pick why, the explain output, the dashboard "editor" columns, and the rendering on the web index, article and public pages, the Atom feed and both EPUB pages. The "Matches: …" interests line stays (restyled in the next commit). The issue_articles.why and candidate_runs.editor_why columns remain in the schema unused; stored issue snapshots that still carry "why" deserialize because Pick ignores unknown fields. Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01ESJbbzQ1b8fs5AA65tKw2q	2026-09-15 00:59:13 +00:00
				`@@ -0,0 +1 @@`
				{% if !related.is_empty() %}<section class="mt-12" aria-labelledby="related-heading"><h2 id="related-heading" class="reader-section-heading">Related</h2><ul class="m-0 list-none p-0">{% for item in related %}<li class="border-b border-rule py-5"><h3 class="font-serif text-xl font-semibold leading-[1.15] tracking-[-0.01em]"><a class="text-ink no-underline hover:text-accent" href="{{ item.href }}">{{ item.title }}</a></h3><p class="mt-1.5 font-sans text-sm text-muted">{% match item.author %}{% when Some with (author) %}{{ author }} · {% when None %}{% endmatch %}{% let source = item.source %}{% include "_source.html" %} · {{ item.reading_minutes }} min read · {{ item.date }}</p></li>{% endfor %}</ul></section>{% endif %}