Orphan removal: the database is the guard (#155 )

backend: remove orphan series from the admin (ticket #155 )
(*Store).RemoveSeries deletes one series row by (site, series_id) via a plain parameterized DELETE; a bookmarks_series_fk violation outside 23503 is translated into the ErrSeriesHasBookmarks sentinel so no driver type escapes the store. The caller reads the row's cover address before the delete and reclaims it after: ReclaimCover's guard cannot pass while a series row still points at the address. POST /admin/series/{key}/remove answers the list row with the removed row's fragment plus the heading re-rendered out of band at the fresh count (HX-Reswap: delete removes the row through the same button that swaps the refusal back in), and navigates from the detail page to the No-Readers list (HX-Redirect for htmx, a 303 for plain clients). A removal that races a fresh Bookmark is a refusal, not a 500: the row re-renders at its new count with the fact spelled out. The control renders only at zero Reader count on both surfaces, gated by hx-confirm with the brief's copy.
2026-08-22 09:58:11 +07:00 · 2026-08-22 09:55:01 +07:00 · 2026-08-22 09:37:08 +07:00 · 2026-08-22 09:36:45 +07:00 · 2026-08-22 09:34:02 +07:00 · 2026-08-22 09:32:25 +07:00
55 changed files with 481 additions and 5104 deletions
@@ -1,49 +1,108 @@
 ---
 name: implement-tickets
-description: "Run a planned wave of tickets: one implementer subagent per ticket in its own worktree, then land, merge and close what comes back."
+description: "Orchestrate a batch of tickets: plan the briefs, then hand each ticket to its own implementer subagent in its own worktree."
 disable-model-invocation: true
 ---
 # Implement tickets
-You are the **orchestrator**. You dispatch, land results, and talk to the
+You are the **orchestrator**. You write briefs, dispatch, land results, and talk
-tracker. You do not write the implementation — every line of ticket code is
+to the tracker. You do not write the implementation — every line of ticket code
-written by a `ticket-implementer` subagent in its own git worktree. Reach for the
+is written by a `ticket-implementer` subagent in its own git worktree. Reach for
-editor yourself only for a merge conflict resolution.
+the editor yourself only for a merge conflict resolution.
 Ticket source and tracker conventions: `docs/agents/issue-tracker.md`. `tea` usage: skill `gitea`.
-## 0. Load the plan
+## 1. Collect the tickets
-Your argument is the batch slug. Read `.scratch/<batch-slug>/plan.md` — it gives
+The user's argument is the selector: issue numbers, a label, a parent issue, or
-the base branch, the waves, the contracts, and each ticket's brief path and
+nothing. With nothing, take the open issues labelled `ready-for-agent`.
 status. Run the earliest wave that is not landed.
-The briefs are the requirements and they are already approved: read each one you
+Fetch each with `tea issue <n> --comments`, and read the **whole** body —
-are about to dispatch, but do not rewrite it, and do not fetch the tickets from
+acceptance criteria and the `Blocked by` line are what the rest of this skill
-the tracker to second-guess it. A brief that is wrong or thin is a `plan-tickets`
+runs on. A ticket whose blockers are still open is out of this batch unless a
-problem — say so and stop, rather than patching it here.
+blocker is also in it.
-No plan file, or no briefs for the next wave: run `plan-tickets` first. That
+## 2. Plan the batch
 skill owns wave membership, contracts, and every brief.
-## 1. Dispatch the wave
+Explore enough of the codebase to write briefs a fresh context can act on: the
 files each ticket lands in, the patterns it must follow, the `AGENTS.md`
 invariants it touches.
 Then decide three things:
 - **Waves.** Blocking edges set the order; tickets with no open blocker inside
  the batch share a wave. Cap each wave at **3** concurrent tickets unless the
  user set another width.
 - **Contracts.** Two tickets in one wave that meet at a function signature, a
  JSON shape, a table column, or a token name: you decide the shape now and
  write the identical wording into both briefs. A contract left for the
  subagents to negotiate is a merge conflict you scheduled.
 - **Splits.** A ticket too big for one fresh context window goes into the wave
  as two briefs, or back to the user.
 ## 3. Get the plan approved
 Present, and stop:
 - the wave list, and for each ticket: number, title, one-line brief summary,
  the files or areas it will touch, its verification commands
 - every cross-ticket contract, verbatim as it will appear in the briefs
 - anything you had to assume
 Wait for approval. Apply the user's edits to the plan, do not relitigate them.
 ## 4. Run a wave
 Per ticket, before dispatch:
 ```bash
-git worktree add ../ticket-<n> -b ticket/<n>-<slug> <base>   # base = the plan's base branch, checked out here
+git worktree add ../ticket-<n> -b ticket/<n>-<slug> <base>   # base = the branch you are on
 cp .env ../ticket-<n>/ 2>/dev/null                            # gitignored, worktrees do not get it
 tea issue edit <n> --add-assignees <your gitea username>      # tea login list has it
 ```
 Write the brief to `.scratch/<batch-slug>/t<n>-brief.md` using the template
 below, in the ubiquitous language of `CONTEXT.md` — a brief that says "scrape"
 where the domain says Poll hands the subagent the wrong model of the system.
 Then dispatch the whole wave in **one** `task` batch, every item on the
 `ticket-implementer` agent. Each dispatch names: the absolute brief path, the
 worktree path, the branch, the base ref, and the report path
-`.scratch/<batch-slug>/t<n>-report.md`. Mark each ticket `dispatched` in the plan
+`.scratch/<batch-slug>/t<n>-report.md`.
 file.
-## 2. Land the wave
+<brief-template>
 # Ticket #<n> — <title>
 **Read first.** `tea issue <n> --comments` for this ticket, then the issue it
 refers to — the parent or spec — the same way. The comments carry decisions the
 body never got updated with. This brief stays the requirements; those two reads
 are the intent behind them.
 **Goal.** The end-to-end behaviour this ticket makes work, from the user's side.
 **Acceptance criteria.** Verbatim from the ticket.
 **Contract.** The exact shared signatures / shapes / names this ticket must
 implement or consume, and which sibling ticket is on the other end. Omit when
 the ticket touches nothing shared.
 **Where it lands.** The files and packages, and the existing pattern to follow
 in each.
 **Binding invariants.** The `AGENTS.md` rules this change can break — name them.
 **TDD seams.** Where a test comes first — run the `tdd` skill at each one and
 follow its red → green loop. Or "none — verify after".
 **Verify.** The exact commands, e.g. `cd backend && go test ./...`,
 `node --test userscript/test/logic.test.js`.
 **Out of scope.** What not to touch, especially a sibling ticket's files.
 </brief-template>
 ## 5. Land the wave
 The wave is landed when every ticket in it is closed, reverted, or handed back
 to the user. Per returned ticket:
@@ -61,17 +120,14 @@ clash — both sides green apart, wrong together — goes back to whichever tick
 owns the contract, as a re-dispatch with the collision described.
 Then `tea comment <n> "<the report summary>"`, `tea issue close <n>`, and
-`git worktree remove ../ticket-<n>`. Keep the report file, and mark the ticket
+`git worktree remove ../ticket-<n>`. Keep the report file.
 `landed` or `handed back` in the plan file.
-## 3. Hand back or close the batch
+Only once the whole wave is landed does the next wave start — its briefs may
 need what this one changed.
-Waves left in the plan: stop and say which wave is next. Its briefs are written
+## 6. Close the batch
 by `plan-tickets` against the base you just changed — that is why they were not
 written up front, and why you do not write them.
-Last wave landed: run the full suite once on the merged base, and report a line
+Run the full suite once on the merged base, and report: a line per ticket with
-per ticket with its status, commits, and open concerns, plus anything still
+its status, commits, and open concerns, plus anything still assigned or open on
-assigned or open on the tracker. A red suite after every ticket went green is an
+the tracker. A red suite after every ticket went green is an interaction bug —
-interaction bug — diagnose it, name the two tickets, and fix it or hand it back
+diagnose it, name the two tickets, and fix it or hand it back with both named.
 with both named.
@@ -1,125 +0,0 @@
 ---
 name: plan-tickets
 description: "Plan a batch of tickets and write the briefs for its next wave: read the tracker, decide waves and contracts, get the plan approved."
 disable-model-invocation: true
 ---
 # Plan tickets
 You produce the two artifacts the `implement-tickets` skill runs on: a **plan
 file** and one **brief** per ticket in the next wave. You write no ticket code
 and create no worktrees — that is the runner's half.
 Ticket source and tracker conventions: `docs/agents/issue-tracker.md`. `tea` usage: skill `gitea`.
 Called twice in a batch's life, at least: once to open it, then again after each
 wave lands, because a later wave's briefs may need what the last one changed. On
 a re-entry, read the existing `.scratch/<batch-slug>/plan.md` first and plan only
 the next unlanded wave — the waves and contracts already approved there stand
 unless the landed wave proved one wrong.
 ## 1. Collect the tickets
 The user's argument is the selector: issue numbers, a label, a parent issue, or
 nothing. With nothing, take the open issues labelled `ready-for-agent`.
 Fetch each with `tea issue <n> --comments`, and read the **whole** body —
 acceptance criteria and the `Blocked by` line are what the rest of this skill
 runs on. A ticket whose blockers are still open is out of this batch unless a
 blocker is also in it. Read the issue each ticket refers to, its parent or spec,
 the same way: nothing on the implementation path reads the tracker after you —
 only `cr-spec` does, at review time — so a decision that lives in a comment
 reaches the implementer only if you carry it into the brief.
 ## 2. Plan the batch
 Explore enough of the codebase to write briefs a fresh context can act on: the
 files each ticket lands in, the patterns it must follow, the `AGENTS.md`
 invariants it touches.
 Then decide three things:
 - **Waves.** Blocking edges set the order; tickets with no open blocker inside
  the batch share a wave. Cap each wave at **3** concurrent tickets unless the
  user set another width.
 - **Contracts.** Two tickets in one wave that meet at a function signature, a
  JSON shape, a table column, or a token name: you decide the shape now and
  write the identical wording into both briefs. A contract left for the
  subagents to negotiate is a merge conflict you scheduled.
 - **Splits.** A ticket too big for one fresh context window goes into the wave
  as two briefs, or back to the user.
 ## 3. Write the artifacts
 Pick a `<batch-slug>` — short, from what the batch is about — and write
 `.scratch/<batch-slug>/plan.md`. It is the handoff: the runner is a fresh context
 that reads this and nothing of your reasoning.
 <plan-template>
 # Batch <batch-slug>
 **Base branch.** The branch every worktree forks from and merges back into.
 **Waves.** A table: wave number, ticket number, title, brief path, and status —
 `planned` | `dispatched` | `landed` | `handed back`. Every ticket in the batch,
 including waves not briefed yet.
 **Contracts.** Each cross-ticket contract verbatim, naming both ticket numbers.
 **Assumptions.** What you had to assume, and what the user corrected at approval.
 </plan-template>
 Then write a brief per ticket in the next wave to
 `.scratch/<batch-slug>/t<n>-brief.md`, using the template below, in the
 ubiquitous language of `CONTEXT.md` — a brief that says "scrape" where the domain
 says Poll hands the subagent the wrong model of the system.
 <brief-template>
 # Ticket #<n> — <title>
 **Decisions.** Whatever the ticket's comments or its parent spec settled that
 the body never got updated with, restated verbatim. The implementer reads this
 brief and the code, never the tracker — a decision missing here is lost to it,
 and a stale comment thread is not a source you want a fresh context guessing
 from. Omit only when the ticket has no comments.
 **Goal.** The end-to-end behaviour this ticket makes work, from the user's side.
 **Acceptance criteria.** Verbatim from the ticket.
 **Contract.** The exact shared signatures / shapes / names this ticket must
 implement or consume, and which sibling ticket is on the other end. Omit when
 the ticket touches nothing shared.
 **Where it lands.** The files and packages, and the existing pattern to follow
 in each.
 **Binding invariants.** The `AGENTS.md` rules this change can break — name them.
 **TDD seams.** Where a test comes first — run the `tdd` skill at each one and
 follow its red → green loop. Or "none — verify after".
 **Verify.** The exact commands, e.g. `cd backend && go test ./...`,
 `node --test userscript/test/logic.test.js`.
 **Out of scope.** What not to touch, especially a sibling ticket's files.
 </brief-template>
 ## 4. Get the plan approved
 Present, and stop:
 - the wave list, and for each ticket in the next wave: number, title, one-line
  brief summary, the files or areas it will touch, its verification commands
 - every cross-ticket contract, verbatim as it appears in the briefs
 - anything you had to assume
 Wait for approval. Apply the user's edits to the plan, do not relitigate them —
 into the files, not just the reply, or the runner never sees them.
 Then hand off: name the batch slug and the wave, and stop. Running the wave is
 `implement-tickets`.
@@ -100,13 +100,7 @@ DISCORD_REDIRECT_URI=
 # every kagane poll. Left unset here on purpose — a wrong default would poll a
 # stranger's address, and "no browser" is a safe, self-announcing state.
 # BROWSER_WS_URL=ws://100.x.y.z:9222
-#
+
 # Discord webhook for owner notices (outbound alerting when a poll Lane
 # stalls). Unset means the whole path is off — a local stack needs no webhook,
 # exactly as the browser URL behaves. The address is a secret in the class of
 # TOKEN_KEY: never commit it, never paste it anywhere public.
 # DISCORD_WEBHOOK_URL=https://discord.com/api/webhooks/...
 #
 # Zone the backend stamps its log lines in. Cosmetic only. Nothing else in
 # the service has a zone: bookmark timestamps are unix ms, and the two real
 # time columns are timestamptz. Defaults to Asia/Jakarta; set to UTC for the
@@ -24,35 +24,34 @@ Your branch is already checked out there. Never `git checkout`, `git switch`,
 ## Order of work
-1. Read the brief file. It is the only statement of requirements you get — use
+1. Read the brief file. It is the single source of requirements — use its exact
-   its exact values verbatim, and read nothing from the tracker. The
+   values verbatim.
-   orchestrator has already read the ticket, its comments and its parent spec,
+2. Read the ticket and the issue it refers to, as the brief's **Read first**
-   and folded every live decision into the brief; the threads themselves also
+   section names them: `tea issue <n> --comments` for each. The ticket's
-   hold reversed and rejected ones you cannot tell apart from here.
+   comments and its parent carry the intent and the decisions behind the brief.
-2. Read `AGENTS.md` in the worktree, plus the nested `AGENTS.md` for the area
+   Read no other ticket and no other brief.
 3. Read `AGENTS.md` in the worktree, plus the nested `AGENTS.md` for the area
   you touch. Its invariants bind you: security rules, design system, comment
   policy.
-3. Ask before writing code if requirements, acceptance criteria, approach, or
+4. Ask before writing code if requirements, acceptance criteria, approach, or
   dependencies are unclear. Asking is free; guessing is not.
-4. Implement exactly what the brief specifies. At each TDD seam the brief names,
+5. Implement exactly what the brief specifies. At each TDD seam the brief names,
   run the `tdd` skill and follow its red → green loop.
   Follow the patterns already in the codebase; improve what you touch,
   restructure nothing outside the ticket.
-5. Verify. Focused tests while iterating, the brief's full verification commands
+6. Verify. Focused tests while iterating, the brief's full verification commands
   once at the end. Test output must be pristine.
-6. Commit to your branch. Reference the ticket number in the subject.
+7. Commit to your branch. Reference the ticket number in the subject.
-7. Review (below), fix, re-verify, commit the fixes.
+8. Review (below), fix, re-verify, commit the fixes.
-8. Write the report file, then return the status contract.
+9. Write the report file, then return the status contract.
 ## Review
 After your first green commit, run the **`code-review`** skill over
 `<base ref>...HEAD` in the worktree, with two changes to how it dispatches:
 use the **`cr-spec`** agent for the Spec axis and **`cr-standards`** for the
-Standards axis, both in one batch, and hand the Spec axis your brief file as the
+Standards axis, both in one batch, and give the Spec axis your brief file plus
-spec plus the ticket number from the brief's title, telling it to read the
+the ticket body as the spec.
 ticket itself (`tea issue <n> --comments`). The tracker check belongs in that
 read-only context, not in yours.
 Fix every Critical and Important finding, then re-run the tests that cover the
 amended code. Two fix rounds maximum: anything still open after that goes in the
@@ -95,7 +95,7 @@ _Avoid_: run, cycle, tick, batch, poll history
 **Forced Poll**:
 A Poll the owner asks for by hand instead of waiting for the Series's turn. It jumps its
 Lane's queue and ignores every waiting rule — the rest between Polls, a Sighting standing
-in for a check, a finished Series — but never overrules a Site that is
+in for a check, a Series only finished Readers hold — but never overrules a Site that is
 refusing us, the Lane's spacing between fetches, or a Series with no page to fetch. Asked
 for by marking the Series, never by commanding the poller, so it happens on the Lane's
 next pass rather than at the moment of asking.
@@ -149,22 +149,10 @@ accent is permitted to signal.
 _Avoid_: unread, update available
 **Lifecycle bucket**:
-Which of the two states a Bookmark sits in — reading or archived. A Bookmark is in exactly
+Which of three mutually exclusive states a Bookmark sits in — reading, archived, or
-one. Orthogonal to being a favourite. Finished is not a bucket: it is a fact about the
+finished. A Bookmark is in exactly one. Orthogonal to being a favourite.
 Series (see `series.finished_at`), owned by the owner and stamped once, and every Bookmark
 on a finished Series is archived.
 _Avoid_: state, status (as a domain word), list
 **Finished Series**:
 A Series the owner has marked finished, stamped once in `series.finished_at`
 (epoch ms, zero means not finished). The owner is its only writer — no
 adapter, no Reader, no Poll can set it — and a Forced Poll reads a finished
 Series once for that pass and never clears the flag. It is a fact about the
 Series, not a Bookmark bucket: every Bookmark on a finished Series is
 archived, the Lane stops polling it (the due gate reads `finished_at = 0`),
 and Readers see a label and nothing more.
 _Avoid_: completed, done, dropped, shelved (that is Archived), ended
 **Favourite**:
 A reader's manual pin on a Bookmark. Orthogonal to the Lifecycle bucket, and never a
 reason to reorder the list.
@@ -29,8 +29,8 @@ Not a public reading tracker or social app — a private, self-hosted sync layer
 ## Capabilities and Constraints
- Two libraries (manga, novels) with lifecycle tabs: All / Updated / Favourites / Archived. Search-filter by title (client-side, `filter.js`).
+- Two libraries (manga, novels) with lifecycle tabs: All / Updated / Favourites / Archived / Finished. Search-filter by title (client-side, `filter.js`).
- Card actions: continue (opens source site), toggle favourite, manual chapter override, archive, remove — each move out of the list confirm-gated.
+- Card actions: continue (opens source site), toggle favourite, manual chapter override, archive, finish, remove — each move out of the list confirm-gated.
 - "Continue reading" horizontal strip for series with an unread chapter.
 - A Reader with no bookmarks at all sees a deliberate empty library offering both userscript install links, not an error and not a blank page.
 - Isolation is the load-bearing invariant: two Readers cannot see or change each other's bookmarks. A series both track is one shared row polled once, with independent progress on each side.
@@ -218,10 +218,10 @@ desktop for faster testing — install the same file unchanged.
  keeps checking it for new chapters, so it is worth coming back to. Archiving
  does not touch read progress, and reading an archived series leaves it
  archived.
- **Finished**: the owner marks a Series finished from its detail page; the
+- **Finished**: series you have completed live in a **Finished** tab in the web
-  backend stops polling it, and every Reader sees a read-only label. It is a
+  UI only. It is set there and nowhere else — the API rejects the value — and
-  fact about the Series, not a Reader's bucket: old `Finished` bookmarks were
+  finished series are hidden from every userscript tab and are no longer polled
-  folded into Archived in the cutover, so there is no Finished tab.
+  for new chapters.
 - Bookmarks made on Asura appear when the panel is opened on Demonic, and vice
  versa — the backend is the shared store.
@@ -159,15 +159,6 @@ failures. The flag decays and they probe again.
 - Browser Lanes wake Chrome only when 5+ Series are due or one has waited 15m,
  and cover work runs in the background so a slow CDN can't eat a Lane's gap.
 ### Owner notices — `internal/notify`, `latest.Fault`, `latest.Notifier`, `latest.FaultsFrom`
 The poller's outbound owner-notice path (issue #171): one condition today
 (the stall), judged from the durable pass log alone so the poller and any
 future reader of the same judgement cannot disagree. The webhook address is a
 secret in the class of TOKEN_KEY — never logged, never rendered, never
 carried in an error. The `owner_notices` suppression table (one row per
 condition + site) is the only state; every threshold is derived, not stored.
 ### Covers — `Store.OnSeriesCreated`, `latest.Acquirer`, `latest.CoverBytesFetcher`, `Store.SetSeriesCover`
 Acquired once when the first Bookmark of a Series is created, then served from
@@ -209,16 +200,12 @@ stored** and clients must adopt that response rather than their own payload.
 ### Lifecycle buckets — `status` on each bookmark
-`reading` | `archived`, orthogonal to `favorite`. Archived rows appear only
+`reading` | `archived` | `finished`, orthogonal to `favorite`. Archived and
-in their own tab, never in All, Updated, Favourites or the recent strip. The
+finished appear only in their own tab, never in All, Updated, Favourites or the
-poller keeps checking archived series; a finished Series (issue #157) is a
+recent strip. The poller keeps checking archived series and skips finished ones.
 `series.finished_at` fact the Lane gate reads, with every bookmark on it
 archived.
- `PUT /bookmarks/{key}` accepts only the two values; anything else —
+- `finished` is settable only from the web UI; `PUT /bookmarks/{key}` rejects
-  `finished` included — is a plain 400, and the web UI's own status control
+  it with 400.
  validates the same way. The 0016 migration is the only writer of the flag
  today; the undo is writing 0.
 - **An empty incoming status means "keep the stored one"**, and it is resolved
  on the `VALUES` side of `Store.Upsert`, not in the conflict clause:
  `excluded.*` is the post-evaluation row, so a default applied there would
@@ -2,7 +2,6 @@ package main
 import (
 	"bytes"
 	"database/sql"
 	"encoding/json"
 	"fmt"
 	"net/http"
@@ -299,7 +298,7 @@ func TestFlatWireFieldSet(t *testing.T) {
 		"series_url": true, "cover": true, "last_chapter": true,
 		"last_chapter_num": true, "last_chapter_url": true, "favorite": true,
 		"latest_chapter": true, "latest_chapter_num": true, "updated_at": true,
-		"status": true, "kind": true, "finished": true,
+		"status": true, "kind": true,
 	}
 	checkFlat := func(t *testing.T, payload []byte) map[string]json.RawMessage {
 		t.Helper()
@@ -363,52 +362,6 @@ func TestFlatWireFieldSet(t *testing.T) {
 	checkFlat(t, body2)
 }
 // finished is derived on the wire and read-only: a client PUT echoing a cached
 // value, forward progress or not, must not change the Series' retired state,
 // so GET still reports the truth after the echo (issues #157, #160).
 func TestFinishedWireRoundTrip(t *testing.T) {
 	s, url := newTestStoreURL(t)
 	srv := newRouter(s, testConfig())
 	key := "asura:done"
 	putBookmark(t, srv, key, store.Bookmark{
 		Title: "Solo Leveling", SeriesURL: "https://asurascans.com/comics/done",
 		LastChapterNum: 10,
 	})
 	// The store writer for the flag is the admin surface's own and lands in
 	// the same wave (#158), so seed the fact with SQL, like store_test.go.
 	db, err := sql.Open("pgx", url)
 	if err != nil {
 		t.Fatalf("open db: %v", err)
 	}
 	defer db.Close()
 	if _, err := db.Exec(
 		`UPDATE series SET finished_at = 1000 WHERE site = 'asura' AND series_id = 'done'`); err != nil {
 		t.Fatalf("seed finished: %v", err)
 	}
 	got := getBookmarks(t, srv)
 	if len(got) != 1 || !got[0].Finished {
 		t.Fatalf("GET = %+v, want one bookmark carrying finished: true", got)
 	}
 	// A stale cache echoing the flag cannot un-finish (or finish) the Series.
 	for _, sent := range []bool{false, true} {
 		echoed := putBookmark(t, srv, key, store.Bookmark{
 			Title: "Solo Leveling", SeriesURL: "https://asurascans.com/comics/done",
 			LastChapterNum: 11, Finished: sent,
 		})
 		if !echoed.Finished {
 			t.Fatalf("PUT echoing Finished: %v reported finished = false, want true", sent)
 		}
 		got = getBookmarks(t, srv)
 		if !got[0].Finished {
 			t.Fatalf("GET after echoing Finished: %v = false, want the Series state preserved", sent)
 		}
 	}
 }
 // A PUT naming an existing series must ignore client-supplied title, cover and
 // URL — the security boundary from ADR-0003, where a hostile site's scraped
 // values could otherwise land on a shared row — while progress still lands.
@@ -73,11 +73,14 @@ func (h *Handler) Put(w http.ResponseWriter, r *http.Request) {
 	}
 	// An empty status is "no opinion" and Upsert keeps the stored bucket.
-	// Anything else outside the two lifecycle buckets is a client bug, not
+	// Finishing a series is a web-UI decision, so the JSON API refuses it
-	// something to silently coerce — finished included, which is no longer a
+	// rather than trusting every client to leave it alone.
 	// bucket at all (issue #157).
 	switch b.Status {
 	case "", store.StatusReading, store.StatusArchived:
 	case store.StatusFinished:
 		http.Error(w, "status "+store.StatusFinished+" can only be set from the web UI",
 			http.StatusBadRequest)
 		return
 	default:
 		http.Error(w, "invalid status", http.StatusBadRequest)
 		return
@@ -1,210 +0,0 @@
 package latest
 import (
 	"context"
 	"fmt"
 	"time"
 	"bookmarkmanager/backend/internal/store"
 )
 // ConditionStall is the owner-notice machine word for a Lane that owed Polls,
 // made none, and has nothing to say for it. The word is the message's footer
 // and its suppression key; it is wire-stable. #172 declares the other three
 // words (no-browser-route, sidecar-down, adapter-broken); this ticket
 // declares only the stall.
 const ConditionStall = "stall"
 // ConditionNoBrowserRoute is the owner-notice machine word for a Site whose
 // challenge refuses for longer than the owner window with no browser route
 // to clear it — the 403-with-interstitial the reader maps to
 // errChallengeHeld (read.go), which plain TLS cannot clear. The word is the
 // message's footer and its suppression key; it is wire-stable.
 const ConditionNoBrowserRoute = "no-browser-route"
 // ConditionSidecarDown is the owner-notice machine word for a browser
 // sidecar no Lane has reached for longer than the owner window: every
 // browser-backed Lane's latest pass is a sidecar skip. The word is the
 // message's footer and its suppression key; it is wire-stable, and its
 // suppression row holds the empty Site (AC4).
 const ConditionSidecarDown = "sidecar-down"
 // ConditionAdapterBroken is the owner-notice machine word for a Site whose
 // adapter stopped finding chapters: more than half of its Series hold an
 // old no-chapter failure row. The word is the message's footer and its
 // suppression key; it is wire-stable.
 const ConditionAdapterBroken = "adapter-broken"
 // OwnerWindow is the class-level staleness boundary every owner-notice
 // condition measures against — the same twelve hours the Lanes page's
 // "not checked in 12h" filter uses (internal/web/admin.go). Declared here
 // once so #172's three conditions and the admin filters share one figure.
 const OwnerWindow = 12 * time.Hour
 // Fault is one condition the owner is told about, judged from durable rows
 // alone. Site is "" for a fault that is not one Site's.
 type Fault struct {
 	Condition string // one of the Condition* words
 	Site      string
 	Since     int64 // unix ms the episode began; the message's age
 }
 // FaultInput is everything the judgement reads. A struct so #172's three
 // conditions can add inputs without changing either caller.
 type FaultInput struct {
 	Passes []store.LanePass
 	// RefusingSince is, per Site, the unix ms when that Site's current
 	// unbroken run of refusing passes began, or absent when its latest pass
 	// did not refuse. Its zero value is an empty map, which contributes no
 	// fault.
 	RefusingSince map[string]int64
 	// SidecarOK is, per browser-backed Site, the unix ms of that Site's most
 	// recent pass that actually reached the sidecar. Zero when the pass log
 	// holds none — an asleep Lane never reached it and never counts as
 	// evidence either way. Its zero value is an empty map.
 	SidecarOK map[string]int64
 	// NoChapterShare is, per Site, the share of that Site's Series holding a
 	// no-chapter failure row older than the owner window. Its zero value is
 	// an empty map, which contributes no fault.
 	NoChapterShare map[string]float64
 }
 // FaultsFrom judges the owner-notice conditions from durable rows alone, so
 // the poller and the landing page cannot disagree about what a fault is.
 //
 // A Lane stalls when its latest pass shows due > 0, none checked, no skip
 // value and no refusal — exactly the row the mid-loop browser loss writes
 // (see the comment at the outcomeUnreachable return in runLanePass), so a
 // Lane that owed Polls, made none, and has nothing to say for it is a fault.
 // The three #172 conditions share the same OwnerWindow boundary and the same
 // fail-open shape: an input's absence contributes no fault, never a false
 // one.
 //
 //   - no-browser-route: a Site whose refusing run began before the window
 //     and that has no browser route to clear the challenge (AC2). Both
 //     refusal shapes count — the gate's skip='refusing' rows and the loop's
 //     refused>0 rows (the twice-refused break writes skip="") — so the run
 //     stays unbroken across them, and one healthy pass ends it.
 //   - sidecar-down: every browser-backed Site's latest pass is a sidecar
 //     skip — SkipSidecarDown or SkipNoFetcher, the two early returns that
 //     record a skip value — and each Site's most recent sidecar-reaching
 //     pass is older than the window (AC4). The skip clause is what keeps
 //     SkipAsleep out: a Lane under both wake thresholds is the commonest
 //     healthy state, never reached the sidecar, and would otherwise age into
 //     a false alarm. Emitted once, with Site "" (AC4's one row per episode).
 //   - adapter-broken: more than half of one Site's Series hold a no-chapter
 //     failure row older than the window (AC6). Strictly above half: the
 //     filter is the tool, and one Site change makes hundreds of rows, so a
 //     single failing Series never fires (AC7). The episode's age is the
 //     window — the old rows prove the episode is at least that old.
 func FaultsFrom(in FaultInput, now time.Time) []Fault {
 	var faults []Fault
 	for _, p := range in.Passes {
 		if p.Due > 0 && p.Checked == 0 && p.Skip == "" && p.Refused == 0 {
 			faults = append(faults, Fault{Condition: ConditionStall, Site: p.Site, Since: p.RanAt})
 		}
 	}
 	cutoff := now.Add(-OwnerWindow).UnixMilli()
 	for site, since := range in.RefusingSince {
 		if since < cutoff && !isBrowserSite(site) {
 			faults = append(faults, Fault{Condition: ConditionNoBrowserRoute, Site: site, Since: since})
 		}
 	}
 	if since, down := sidecarDownSince(in.Passes, in.SidecarOK, cutoff); down {
 		faults = append(faults, Fault{Condition: ConditionSidecarDown, Site: "", Since: since})
 	}
 	for site, share := range in.NoChapterShare {
 		if share > 0.5 {
 			faults = append(faults, Fault{Condition: ConditionAdapterBroken, Site: site, Since: now.Add(-OwnerWindow).UnixMilli()})
 		}
 	}
 	return faults
 }
 // sidecarDownSince reports whether no browser Lane has reached the sidecar
 // for longer than the owner window and, when it has, the last moment any
 // Lane reached it. The skip clause — every browser-backed Site's latest pass
 // must be SkipSidecarDown or SkipNoFetcher — keeps SkipAsleep out (see
 // FaultsFrom). A Site with no pass row at all is not judged down either: a
 // fresh database is not a dead sidecar.
 func sidecarDownSince(passes []store.LanePass, ok map[string]int64, cutoff int64) (since int64, down bool) {
 	latest := make(map[string]store.LanePass, len(passes))
 	for _, p := range passes {
 		latest[p.Site] = p
 	}
 	for _, site := range browserBackedSites() {
 		p, found := latest[site]
 		if !found || (p.Skip != SkipSidecarDown && p.Skip != SkipNoFetcher) {
 			return 0, false
 		}
 		reached := ok[site]
 		if reached > 0 && reached >= cutoff {
 			return 0, false
 		}
 		if reached > since {
 			since = reached
 		}
 	}
 	// No Lane's retained pass log shows a sidecar reach: the honest age is
 	// the window itself — "at least twelve hours" — not the epoch, which
 	// humanAge would render as tens of thousands of days.
 	if since == 0 {
 		since = cutoff
 	}
 	return since, true
 }
 // Notifier delivers one owner notice. The poller neither retries nor queues:
 // an error is logged and the suppression row left unwritten, so the next pass
 // tries again while the condition holds.
 type Notifier interface {
 	Notify(ctx context.Context, f Fault, sentence, href string) error
 }
 // ownerNoticeConditions is every condition this package judges, for the
 // clear loop in recordPass: a condition absent from a pass's fault list
 // forgets its episode, so the next occurrence sends again. #172 extends the
 // list when it adds its conditions.
 var ownerNoticeConditions = []string{ConditionStall, ConditionNoBrowserRoute, ConditionSidecarDown, ConditionAdapterBroken}
 // noticeFor renders one fault's message: the description sentence — condition,
 // age, repair — and the deep link the embed's title points at. Each condition
 // provides its own wording; the stall is the only one today (issue #171).
 func noticeFor(f Fault, row store.LanePass, now time.Time) (sentence, href string) {
 	switch f.Condition {
 	case ConditionStall:
 		return fmt.Sprintf(
 			"%s owed %d Polls and made none — %s; check the Lane's browser sidecar and the Site's challenge state",
 			f.Site, row.Due, humanAge(now.Sub(time.UnixMilli(f.Since)))), "/admin/lanes"
 	case ConditionNoBrowserRoute:
 		return fmt.Sprintf(
 			"%s has refused for %s with no browser route — the challenge does not clear on plain TLS; redeploy or add a browser route",
 			f.Site, humanAge(now.Sub(time.UnixMilli(f.Since)))), "/admin/lanes"
 	case ConditionSidecarDown:
 		return fmt.Sprintf(
 			"no browser Lane has reached the sidecar for %s — the browser sidecar is down; start or repair the browser machine",
 			humanAge(now.Sub(time.UnixMilli(f.Since)))), "/admin/lanes"
 	case ConditionAdapterBroken:
 		return fmt.Sprintf(
 			"more than half of %s's Series have failed no-chapter reads for at least %s — the Site's layout changed and the adapter is broken",
 			f.Site, humanAge(now.Sub(time.UnixMilli(f.Since)))), "/admin/lanes"
 	}
 	return "", ""
 }
 // humanAge renders a duration the way an owner reads it in a message: minutes
 // under an hour, then hours, then days; a stall that was just born reads
 // "just now".
 func humanAge(d time.Duration) string {
 	switch {
 	case d < time.Minute:
 		return "just now"
 	case d < time.Hour:
 		return fmt.Sprintf("%dm", int(d.Minutes()))
 	case d < 24*time.Hour:
 		return fmt.Sprintf("%dh", int(d.Hours()))
 	default:
 		return fmt.Sprintf("%dd", int(d.Hours()/24))
 	}
 }
@@ -46,9 +46,6 @@ type Poller struct {
 	// CoverBytesFetch is optional; it handles plain-TLS sources through the
 	// same failure-isolated prefetch path.
 	CoverBytesFetch CoverBytesFetcher
 	// Notify delivers owner notices. Nil disables the whole path (issue #171):
 	// the poller is not the place a missing webhook becomes an error.
 	Notify Notifier
 	Now             func() time.Time // injected so tests can freeze it
 	// eligibleCount reports how many of a Site's Series are eligible for
 	// polling, defaulting to Store.EligibleSeriesCount. Injected so tests can
@@ -276,9 +273,7 @@ const (
 // (issue #141). The classification the read already makes is counted, never a
 // second taxonomy: refused is the Site holding a challenge, unreachable the
 // browser interrupting, noChapter a 200 with real HTML but no chapter links,
-// unfetchable the host pin or a missing fetcher, notFound a 4xx other than
+// unfetchable the host pin or a missing fetcher, and errors everything else.
 // the 403 refusal — the Site answered with a client status — and errors
 // everything else.
 type readOutcome int
 const (
@@ -288,33 +283,14 @@ const (
 	outcomeNoChapter
 	outcomeUnfetchable
 	outcomeError
 	outcomeNotFound
 )
 // word returns the wire spelling this outcome stores in poll_failures — the
 // same strings the pass log's columns use (C1, issue #164). Success, refusal
 // and browser loss return "" so recordFailure's "no statement" case is one
 // return: a challenge or a lost sidecar is no evidence about any particular
 // Series (ADR-0016).
 func (o readOutcome) word() string {
 	switch o {
 	case outcomeNotFound:
 		return "not_found"
 	case outcomeNoChapter:
 		return "no_chapter"
 	case outcomeUnfetchable:
 		return "unfetchable"
 	case outcomeError:
 		return "errors"
 	}
 	return ""
 }
-// outcomeCounts are the six named outcome counts of one pass. A success
+// outcomeCounts are the five named outcome counts of one pass. A success
-// count is derived, never stored: checked minus the five named failures,
+// count is derived, never stored: checked minus the four, with unreachable
-// with unreachable excluded because the sidecar-loss path returns before the
+// excluded because the sidecar-loss path returns before the checked counter
-// checked counter increments (issue #141).
+// increments (issue #141).
 type outcomeCounts struct {
-	refused, unreachable, noChapter, unfetchable, errors, notFound int
+	refused, unreachable, noChapter, unfetchable, errors int
 }
 func (c *outcomeCounts) add(o readOutcome) {
@@ -327,8 +303,6 @@ func (c *outcomeCounts) add(o readOutcome) {
 		c.noChapter++
 	case outcomeUnfetchable:
 		c.unfetchable++
 	case outcomeNotFound:
 		c.notFound++
 	case outcomeError:
 		c.errors++
 	}
@@ -360,7 +334,7 @@ func (p *Poller) runLanePass(ctx context.Context, name string, paced bool) time.
 	// carries the previous pass's forward inside recordPass.
 	fig := passFigures{}
 	rec := passRecord{site: name, ranAt: now.UnixMilli()}
-	defer func() { p.recordPass(ctx, rec, fig) }()
+	defer func() { p.recordPass(rec, fig) }()
 	// One Lane row read at the top of a pass, serving two gates (issue #139).
 	// Both stamps outlive our process, so the gates read the durable row
@@ -477,7 +451,6 @@ func (p *Poller) runLanePass(ctx context.Context, name string, paced bool) time.
 			}
 		}
 		outcome := p.checkOne(ctx, sr)
 		p.recordFailure(sr, outcome)
 		if outcome == outcomeUnreachable {
 			// The mid-loop browser loss writes an empty skip on purpose: the
 			// pass returns before the checked counter increments, so its row
@@ -530,9 +503,8 @@ type passFigures struct {
 // pass's due, gap, clamped and checked forward rather than stating zeroes it
 // did not measure; the skip column says why it declined, so the zeroes that
 // remain (due-query, no-fetcher) read as explanations rather than
-// measurements. Once the row is durable, the owner-notice judgement runs
+// measurements.
-// beside it (issue #171).
+func (p *Poller) recordPass(rec passRecord, fig passFigures) {
 func (p *Poller) recordPass(ctx context.Context, rec passRecord, fig passFigures) {
 	row := store.LanePass{
 		Site:        rec.site,
 		RanAt:       rec.ranAt,
@@ -545,7 +517,6 @@ func (p *Poller) recordPass(ctx context.Context, rec passRecord, fig passFigures
 		Unreachable: rec.counts.unreachable,
 		NoChapter:   rec.counts.noChapter,
 		Unfetchable: rec.counts.unfetchable,
 		NotFound:    rec.counts.notFound,
 		Errors:      rec.counts.errors,
 	}
 	if row.GapMS == 0 {
@@ -561,111 +532,7 @@ func (p *Poller) recordPass(ctx context.Context, rec passRecord, fig passFigures
 	}
 	if err := p.Store.RecordLanePass(row, rec.ranAt-lanePassRetention.Milliseconds()); err != nil {
 		log.Printf("latest poll %s: record lane pass: %v", rec.site, err)
 		return
 	}
 	p.ownerNotices(ctx, row)
 }
 // ownerNotices judges the owner-notice conditions for the pass just recorded
 // and fires (issue #171). It sits in recordPass because that deferred call is
 // the one place every return path passes through: three of the four
 // conditions occur on early returns and the success path can never see them.
 // The judgement reads the whole pass log plus three derived reads — the
 // other Lanes' latest passes, each Site's refusing-run start, its last
 // sidecar-reaching pass, and its no-chapter share — so one pass judges every
 // condition (issue #172). Per fault: NoticeSent → send → MarkNoticeSent, so
 // a fault lasting a month sends one message, not one per pass; a condition
 // absent from this pass's fault list forgets its episode, so the next
 // occurrence sends again. Everything here is best-effort: a failed send, a
 // failed store read and a failed notice write are all logged and never
 // change the pass's outcome counts or its return value. The clear runs even
 // when Notify is nil, so a deployment that turns the webhook off does not
 // leave stale rows that suppress the first real notice after it is turned
 // back on.
 func (p *Poller) ownerNotices(ctx context.Context, row store.LanePass) {
 	now := p.Now()
 	in := FaultInput{Passes: []store.LanePass{row}}
 	// Each read fails independently: a failure logs and contributes no fault,
 	// never a false one.
 	if passes, err := p.Store.LatestLanePasses(); err != nil {
 		log.Printf("latest poll %s: latest lane passes: %v", row.Site, err)
 	} else {
 		in.Passes = passes
 	}
 	if since, err := p.Store.RefusingSince(now.UnixMilli()); err != nil {
 		log.Printf("latest poll %s: refusing since: %v", row.Site, err)
 	} else {
 		in.RefusingSince = since
 	}
 	if ok, err := p.Store.SidecarOK(browserBackedSites()); err != nil {
 		log.Printf("latest poll %s: sidecar ok: %v", row.Site, err)
 	} else {
 		in.SidecarOK = ok
 	}
 	if share, err := p.Store.NoChapterShare(now.Add(-OwnerWindow).UnixMilli()); err != nil {
 		log.Printf("latest poll %s: no-chapter share: %v", row.Site, err)
 	} else {
 		in.NoChapterShare = share
 	}
 	faults := FaultsFrom(in, now)
 	bySite := make(map[string]store.LanePass, len(in.Passes))
 	for _, pass := range in.Passes {
 		bySite[pass.Site] = pass
 	}
 	for _, f := range faults {
 		if p.Notify == nil {
 			continue
 		}
 		sent, err := p.Store.NoticeSent(f.Condition, f.Site)
 		if err != nil {
 			log.Printf("latest poll %s: notice sent: %v", row.Site, err)
 			continue
 		}
 		if sent {
 			continue
 		}
 		// The fault's own Site's pass renders its sentence — a stall judged
 		// from another Lane's pass must not quote this pass's figures.
 		pass, ok := bySite[f.Site]
 		if !ok {
 			pass = row
 		}
 		sentence, href := noticeFor(f, pass, now)
 		if err := p.Notify.Notify(ctx, f, sentence, href); err != nil {
 			// The stamp stays unset: no queue, no backoff — the condition is
 			// durable, so the next pass tries again while it holds.
 			log.Printf("latest poll %s: owner notice %s: %v", row.Site, f.Condition, err)
 			continue
 		}
 		if err := p.Store.MarkNoticeSent(f.Condition, f.Site, now.UnixMilli()); err != nil {
 			log.Printf("latest poll %s: mark notice sent: %v", row.Site, err)
 		}
 	}
 	for _, cond := range ownerNoticeConditions {
 		if !hasFault(faults, cond, row.Site) {
 			if err := p.Store.ClearNotice(cond, row.Site); err != nil {
 				log.Printf("latest poll %s: clear owner notice: %v", row.Site, err)
 			}
 		}
 	}
 	// sidecar-down suppresses under the empty Site — one row across all
 	// browser Lanes (AC4) — so clear that row when it is absent from this
 	// pass's fault list, and a lifted sidecar fires again when it returns.
 	if !hasFault(faults, ConditionSidecarDown, "") {
 		if err := p.Store.ClearNotice(ConditionSidecarDown, ""); err != nil {
 			log.Printf("latest poll %s: clear owner notice: %v", row.Site, err)
 		}
 	}
 }
 // hasFault reports whether faults hold the given condition for the site.
 func hasFault(faults []Fault, condition, site string) bool {
 	for _, f := range faults {
 		if f.Condition == condition && f.Site == site {
 			return true
 		}
 	}
 	return false
 }
 // countEligible routes the eligible count through the test seam when one is
@@ -740,35 +607,13 @@ func maxSeriesWait(due []store.Series, now time.Time, rest time.Duration) time.D
 	}
 	return oldest
 }
 // recordFailure keeps one Series' failure row in step with its read
 // (ADR-0016): a failure word is upserted, a successful read deletes the row,
 // and refused or unreachable issue no statement at all. Called for every
 // outcome from the pass loop, so the four failure words and the success path
 // share one write point, and a forced Poll that reads the page clears through
 // the ordinary success path — no branch of its own. Log a store failure and
 // carry on: this is best-effort, and no single bad Series may stall a Lane.
 func (p *Poller) recordFailure(sr store.Series, outcome readOutcome) {
 	if outcome == outcomeSuccess {
 		if err := p.Store.ClearSeriesFailure(sr.Site, sr.SeriesID); err != nil {
 			log.Printf("latest poll %q: clear failure: %v", sr.Key(), err)
 		}
 		return
 	}
 	word := outcome.word()
 	if word == "" {
 		return
 	}
 	if err := p.Store.RecordSeriesFailure(sr.Site, sr.SeriesID, word, p.Now().UnixMilli()); err != nil {
 		log.Printf("latest poll %q: record failure: %v", sr.Key(), err)
 	}
 }
 // checkOne re-checks one series. Every failure path here is "log and move on":
 // the poller is a best-effort enhancement, and no single bad series may stall a
 // Lane or take down the process. The returned outcome classifies the read for
 // the pass row (issue #141), so the Lane can count a refusal, a lost browser,
-// a chapter-less page, an unfetchable address, a missing page or a transport
+// a chapter-less page, an unfetchable address or a transport error without
-// error without re-deriving the taxonomy.
+// re-deriving the taxonomy.
 func (p *Poller) checkOne(ctx context.Context, sr store.Series) (outcome readOutcome) {
 	defer func() {
 		if r := recover(); r != nil {
@@ -812,9 +657,6 @@ func (p *Poller) checkOne(ctx context.Context, sr store.Series) (outcome readOut
 		if errors.Is(err, errBrowserInterrupted) {
 			return outcomeUnreachable
 		}
 		if errors.Is(err, errNotFound) {
 			return outcomeNotFound
 		}
 		return outcomeError
 	}
 	// A legacy cover source is healed independently of the page read.
@@ -827,25 +669,6 @@ func (p *Poller) checkOne(ctx context.Context, sr store.Series) (outcome readOut
 	} else {
 		p.fillBlankCover(ctx, sr, facts.Cover)
 	}
 	// Learned from the successful read: the write sits after the error switch
 	// (a refused, unreachable or errored read reaches nothing) and before the
 	// returns below — a completed page whose chapter number did not change
 	// still has to write. The transition is zero-versus-nonzero, not the
 	// stamp's value: a Series still completed keeps its original stamp, so the
 	// age #170 prints is "since the Site first said so"; one that stopped
 	// being completed is zeroed.
 	stamp := int64(0)
 	if facts.SiteCompleted {
 		stamp = p.Now().UnixMilli()
 	}
 	if (sr.SiteCompletedAt == 0) != (stamp == 0) {
 		if err := p.Store.SetSiteCompletedAt(sr.Site, sr.SeriesID, stamp); err != nil {
 			// Best-effort, like every poller write: never change the outcome
 			// word the pass counts.
 			log.Printf("latest poll %q: set site completed: %v", sr.Key(), err)
 		}
 	}
 	if !facts.HasLatest {
 		// Most likely a challenge page or a layout change. Either way the row is
 		// already stamped, so this waits out a rest instead of hot-looping.
@@ -6,19 +6,15 @@ import (
 	"fmt"
 )
-// seriesRead carries the facts the poll and the acquirer both extract from a
+// seriesRead carries the two facts the poll and the acquirer both extract
-// series page. Persistence, stamps and scheduling stay with the callers, so
+// from a series page. Persistence, stamps and scheduling stay with the
-// the policies that keep the two flows distinct (stamp order, rests) are not
+// callers, so the policies that keep the two flows distinct (stamp order,
-// swallowed by the module.
+// rests) are not swallowed by the module.
 type seriesRead struct {
 	Latest    latestChapter
 	HasLatest bool
 	Cover     string
 	HasCover  bool
 	// SiteCompleted is whether the Site's own completed value was on the page.
 	// A challenge body and a redesign both read false — an absent hint, never
 	// a claim (issue #168).
 	SiteCompleted bool
 	// BodyLen is the fetched body's length, surfaced because the no-chapter
 	// log uses it to tell a markup change from a body the size cap cut short.
 	BodyLen int
@@ -29,18 +25,15 @@ type seriesRead struct {
 // errChallengeHeld (browser.go) is the outcome of a Site that answered with
 // its interstitial — status 403 (cf-mitigated) or a challenge page body — and
 // is how a Lane tells a refusal from an ordinary failure (issue #100).
 // errNotFound marks any other 4xx: the page is gone — a fact the owner can act
 // on — as distinct from a Site or database that is merely unwell (issue #164).
 var (
 	errNotFetchable = errors.New("series url not fetchable")
 	errNoFetcher    = errors.New("no fetcher for site")
 	errNotFound     = errors.New("series page not found")
 )
 // readSeriesPage performs the series-page read the poll and the acquirer have
 // in common: gate the address, choose the route, fetch the page, extract the
-// Latest Chapter, the Cover address and the Site's completed value. It
+// Latest Chapter and the Cover address. It persists nothing and stamps
-// persists nothing and stamps nothing.
+// nothing.
 //
 // series_url arrives in a client-supplied PUT body (PUT /bookmarks/{key}
 // accepts any string), so the gate is not an optimisation against burning a
@@ -66,9 +59,6 @@ func readSeriesPage(ctx context.Context, site, seriesURL string, browser, tls Fe
 		return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errChallengeHeld, seriesURL, status)
 	}
 	if status != 200 {
 		if status >= 400 && status < 500 {
 			return seriesRead{}, fmt.Errorf("%w: fetch %s: status %d", errNotFound, seriesURL, status)
 		}
 		return seriesRead{}, fmt.Errorf("fetch %s: status %d", seriesURL, status)
 	}
 	if isInterstitial(body) {
@@ -79,12 +69,5 @@ func readSeriesPage(ctx context.Context, site, seriesURL string, browser, tls Fe
 	}
 	latest, hasLatest := latestChapterFrom(site, seriesURL, body)
 	cover, hasCover := coverFrom(site, seriesURL, body)
-	return seriesRead{
+	return seriesRead{Latest: latest, HasLatest: hasLatest, Cover: cover, HasCover: hasCover, BodyLen: len(body)}, nil
 		Latest:        latest,
 		HasLatest:     hasLatest,
 		Cover:         cover,
 		HasCover:      hasCover,
 		SiteCompleted: siteCompletedFrom(site, seriesURL, body),
 		BodyLen:       len(body),
 	}, nil
 }
@@ -22,10 +22,10 @@ type latestChapter struct {
 // site answers the fixed questions every series-page read asks of its Site
 // (ADR-0009): the host its addresses must carry, how to find the Latest
-// Chapter and the Cover address in a body, whether the Site calls the work
+// Chapter and the Cover address in a body, and — for a Site behind a
-// completed, and — for a Site behind a JavaScript challenge — how to read its
+// JavaScript challenge — how to read its payload from a cleared tab. One
-// payload from a cleared tab. One entry describes everything about one Site,
+// entry describes everything about one Site, and nowhere else gets to compare
-// and nowhere else gets to compare the site string.
+// the site string.
 type site struct {
 	// Host is the exact hostname a series_url for this Site must carry.
 	Host string
@@ -33,10 +33,6 @@ type site struct {
 	LatestChapter func(seriesURL, body string) (latestChapter, bool)
 	// Cover finds the Cover address in a fetched body.
 	Cover func(seriesURL, body string) (string, bool)
 	// Completed reports whether this body carries the Site's own completed
 	// value. False for a body that carries any other value, and false for a
 	// failed extraction — never an error and never a third state.
 	Completed func(seriesURL, body string) bool
 	// Rest is how long a Series of this Site rests between Polls.
 	Rest time.Duration
 	// Gap is the Lane's strictest pace: at least one second must pass between
@@ -303,42 +299,34 @@ func kaganeCoverURL(body string) string {
 	return ""
 }
-// comixDetailQuery returns the ["manga","detail","<id>"] query entry of
+func comixCoverURL(seriesURL, body string) string {
 // comix's initial-data JSON, or nil. The cover and completed reads share the
 // scoped lookup so a "recommended" strip entry can never contribute either
 // answer.
 func comixDetailQuery(seriesURL, body string) json.RawMessage {
 	id, ok := comixSeriesID(seriesURL)
 	if !ok {
-		return nil
+		return ""
 	}
 	data := comixInitialDataRe.FindStringSubmatch(body)
 	if data == nil {
-		return nil
+		return ""
 	}
 	var state struct {
 		Queries map[string]json.RawMessage `json:"queries"`
 	}
 	if err := json.Unmarshal([]byte(data[1]), &state); err != nil {
 		return nil
 	}
 	return state.Queries[`["manga","detail","`+id+`"]`]
 }
 func comixCoverURL(seriesURL, body string) string {
 	detail := comixDetailQuery(seriesURL, body)
 	if len(detail) == 0 {
 		return ""
 	}
-	var entry struct {
+	raw := state.Queries[`["manga","detail","`+id+`"]`]
 	if len(raw) == 0 {
 		return ""
 	}
 	var detail struct {
 		Poster struct {
 			Medium string `json:"medium"`
 		} `json:"poster"`
 	}
-	if err := json.Unmarshal(detail, &entry); err != nil {
+	if err := json.Unmarshal(raw, &detail); err != nil {
 		return ""
 	}
-	return publishedCoverURL(entry.Poster.Medium)
+	return publishedCoverURL(detail.Poster.Medium)
 }
 // ogImageCover reads the og:image metadata shared by asura, demonic and
@@ -372,87 +360,6 @@ func coverFrom(site, seriesURL, body string) (string, bool) {
 	return "", false
 }
 // asuraStatusRe matches the status value inside the escaped astro-island
 // props blob, in both the &quot; form the served document carries and the "
 // form a decoded copy would. "completed" is the only true value: "dropped"
 // is scanlation editorial (the work itself continues elsewhere) and hiatus is
 // its own value.
 var asuraStatusRe = regexp.MustCompile(`(?:&quot;|")status(?:&quot;|"):\[0,(?:&quot;|")completed(?:&quot;|")\]`)
 func asuraCompleted(_, body string) bool {
 	return asuraStatusRe.MatchString(body)
 }
 // demonicStatusRe matches the info block's status pair: a Status label <li>
 // immediately followed by the value <li>. The site's whole status vocabulary
 // is {Ongoing, Completed} (its advanced-search status filter), so the literal
 // Completed value is the entire signal.
 var demonicStatusRe = regexp.MustCompile(`<li[^>]*>\s*Status\s*</li>\s*<li[^>]*>\s*Completed\s*</li>`)
 func demonicCompleted(_, body string) bool {
 	return demonicStatusRe.MatchString(body)
 }
 // comixCompleted reads "status" from the scoped detail entry only;
 // "finished" is the completed value, and on_hiatus and discontinued are
 // distinct values.
 func comixCompleted(seriesURL, body string) bool {
 	detail := comixDetailQuery(seriesURL, body)
 	if len(detail) == 0 {
 		return false
 	}
 	var entry struct {
 		Status string `json:"status"`
 	}
 	if err := json.Unmarshal(detail, &entry); err != nil {
 		return false
 	}
 	return entry.Status == "finished"
 }
 // kaganeCompleted reads publication_status only: upload_status is the
 // release's state, and the two provably diverge ('Cause Calypso Can,
 // 2026-08-19: publication Ongoing, upload Hiatus), so a Completed upload
 // must never read as a Completed work.
 func kaganeCompleted(_, body string) bool {
 	var series struct {
 		PublicationStatus string `json:"publication_status"`
 	}
 	if err := json.Unmarshal([]byte(body), &series); err != nil {
 		return false
 	}
 	return series.PublicationStatus == "Completed"
 }
 // novelfullStatusRe matches the info panel's status link. The page's whole
 // status vocabulary is {Ongoing, Completed} (the "OnGoing" spelling aliases
 // "Ongoing" on the taxonomy), so the Completed href is the signal.
 var novelfullStatusRe = regexp.MustCompile(`href="/status/Completed"`)
 func novelfullCompleted(_, body string) bool {
 	return novelfullStatusRe.MatchString(body)
 }
 // lnwCompleted matches creativeWorkStatus in the head's JSON-LD block. The
 // whole body is scanned and the comment marker is not required, unlike
 // lnwLatestChapter: the status block sits ahead of the visitor-writable
 // thread, and hiatus maps to a distinct PotentialActionStatus value.
 var lnwStatusRe = regexp.MustCompile(`"creativeWorkStatus"\s*:\s*"https://schema\.org/CompletedActionStatus"`)
 func lnwCompleted(_, body string) bool {
 	return lnwStatusRe.MatchString(body)
 }
 // siteCompletedFrom reports whether the Site calls this work completed, via
 // the Site's registry entry. False for an unknown site, a challenge body and
 // a redesign alike: an absent hint, never a claim.
 func siteCompletedFrom(site, seriesURL, body string) bool {
 	if fn := sites[site].Completed; fn != nil {
 		return fn(seriesURL, body)
 	}
 	return false
 }
 // metaContent returns the content of the first <meta> whose attrName is
 // attrValue. It keeps scanning after an empty match so a later published cover
 // is not hidden by an empty tag.
@@ -542,7 +449,6 @@ var sites = map[string]site{
 		Host:          "asurascans.com",
 		LatestChapter: asuraLatestChapter,
 		Cover:         ogImageCover,
 		Completed:     asuraCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 	},
@@ -550,7 +456,6 @@ var sites = map[string]site{
 		Host:          "demonicscans.org",
 		LatestChapter: demonicLatestChapter,
 		Cover:         ogImageCover,
 		Completed:     demonicCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 	},
@@ -558,7 +463,6 @@ var sites = map[string]site{
 		Host:          "comix.to",
 		LatestChapter: comixLatestChapter,
 		Cover:         comixCoverEntry,
 		Completed:     comixCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 		Browser: &browserRead{
@@ -575,7 +479,6 @@ var sites = map[string]site{
 		Host:          "kagane.to",
 		LatestChapter: kaganeLatestChapter,
 		Cover:         kaganeCoverEntry,
 		Completed:     kaganeCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 		Browser: &browserRead{
@@ -590,7 +493,6 @@ var sites = map[string]site{
 		Host:          "novelfull.com",
 		LatestChapter: novelfullLatestChapter,
 		Cover:         novelfullCoverEntry,
 		Completed:     novelfullCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 		Browser: &browserRead{
@@ -605,7 +507,6 @@ var sites = map[string]site{
 		Host:          "lightnovelworld.net",
 		LatestChapter: lnwLatestChapter,
 		Cover:         ogImageCover,
 		Completed:     lnwCompleted,
 		Rest:          defaultRest,
 		Gap:           defaultGap,
 	},
@@ -623,12 +524,6 @@ func SiteNames() []string {
 	return names
 }
 // BrowserBackedSites is derived from the registry: the Sites whose pages are
 // read through the browser sidecar. Sorted so callers that range it (the
 // browser fetcher's dispatch) see a stable order instead of map-iteration
 // noise. Exported so the web layer shares the same set the poller does.
 func BrowserBackedSites() []string { return browserBackedSites() }
 // browserBackedSites is derived from the registry: the Sites whose pages are
 // read through the browser sidecar. Sorted so callers that range it (the
 // browser fetcher's dispatch) see a stable order instead of map-iteration
@@ -188,104 +188,6 @@ const lnwSeriesFixture = `
 </div>
 `
 // Completed-marker fixtures, trimmed from the live pages fetched 2026-08-22
 // for the verification step below. Selector-removed rows delete the marker
 // from the consts and must answer false.
 // Trimmed from https://asurascans.com/comics/solo-leveling (301 to
 // /comics/solo-leveling-b60d532c) fetched 2026-08-22 by a curl probe from
 // this machine. The astro-island props are HTML-escaped in the served
 // document, so the quotes arrive as &quot;.
 const asuraCompletedFixture = `
 &quot;bookmarkCount&quot;:[0,39128],&quot;status&quot;:[0,&quot;completed&quot;],&quot;type&quot;:[0,&quot;manhwa&quot;]
 `
 // Trimmed from https://asurascans.com/comics/chronicles-of-the-demon-faction-f886a8af
 // fetched 2026-08-22 by a curl probe.
 const asuraOngoingFixture = `
 &quot;bookmarkCount&quot;:[0,54027],&quot;status&quot;:[0,&quot;ongoing&quot;],&quot;type&quot;:[0,&quot;manhwa&quot;]
 `
 // Trimmed from https://demonicscans.org/manga/Solo-Leveling fetched
 // 2026-08-22 by a curl probe. The info block is sloppy: bare <li>s inside a
 // <div>, label and value as a sibling pair.
 const demonicCompletedFixture = `
 <div class="flex flex-row">
    <li style="width:150px;color:#b2b2b2;">Status</li>
    <li>Completed</li>
 </div>
 `
 // Trimmed from https://demonicscans.org/manga/Catastrophic-Necromancer
 // fetched 2026-08-22 by a curl probe. Same block, ongoing value.
 const demonicOngoingFixture = `
 <div class="flex flex-row">
    <li style="width:150px;color:#b2b2b2;">Status</li>
    <li>Ongoing</li>
 </div>
 `
 // Trimmed from https://comix.to/title/q77m-countach fetched 2026-08-22 by a
 // cleared Chrome tab (the CDP sidecar: the Series URL is fetched in-tab, the
 // same server-rendered payload the poll reads). The served page escapes the
 // query map keys as \u0022; the fixture carries the decoded form, which
 // parses to the same key. The recommended strip on this very page carries a
 // finished entry; only the ["manga","detail","q77m"] entry counts.
 const comixCompletedFixture = `<script type="application/json" id="initial-data">{"queries":{"[\"manga\",\"recommended\",\"q77m\",1]":{"items":[{"hid":"pz65","title":"Wangan Midnight: C1 Runner","status":"finished"}]},"[\"manga\",\"detail\",\"q77m\"]":{"id":13211,"hid":"q77m","title":"Countach","status":"finished","originalLanguage":"ja"}}}</script>`
 // Trimmed from https://comix.to/title/n8we-dungeons-and-crayons fetched
 // 2026-08-22 the same way (keys in their decoded form, as above). The
 // recommended strip includes a finished entry; the target detail is
 // releasing, and only the detail read counts.
 const comixOngoingFixture = `<script type="application/json" id="initial-data">{"queries":{"[\"manga\",\"recommended\",\"n8we\",1]":{"items":[{"hid":"g2rk","title":"On the Way to Meet Mom","status":"finished"}]},"[\"manga\",\"detail\",\"n8we\"]":{"id":1429,"hid":"n8we","title":"Dungeons and Crayons","status":"releasing","originalLanguage":"ko"}}}</script>`
 // Trimmed from GET https://kagane.to/api/v2/series/019f84bc-9ba0-7ed9-86f5-8b905ec7c28b
 // fetched 2026-08-22 in a cleared Chrome tab (plain TLS serves the Cloudflare
 // challenge).
 const kaganeOngoingFixture = `{"series_id":"019f84bc-9ba0-7ed9-86f5-8b905ec7c28b","title":"Infinite Decryption: The Strongest Level 0","publication_status":"Ongoing","upload_status":"Ongoing"}`
 // Trimmed from GET https://kagane.to/api/v2/series/019c29c3-5abd-70e6-9efc-1f1f22d839f6
 // fetched 2026-08-22 the same way.
 const kaganeCompletedFixture = `{"series_id":"019c29c3-5abd-70e6-9efc-1f1f22d839f6","title":"Real Account 1-17","publication_status":"Completed","upload_status":"Completed"}`
 // Composed, not a single live trim: upload Completed alongside a
 // non-Completed publication status is the research note's inferred inverse
 // case and did not turn up in the ~1900-series live scan of 2026-08-22 (both
 // field vocabularies are live-verified; the note's live divergence is 'Cause
 // Calypso Can, publication Ongoing + upload Hiatus). The predicate must read
 // publication_status only.
 const kaganeDivergentFixture = `{"series_id":"019f84bc-9ba0-7ed9-86f5-8b905ec7c28b","title":"Infinite Decryption: The Strongest Level 0","publication_status":"Ongoing","upload_status":"Completed"}`
 // Trimmed from https://novelfull.com/reverend-insanity.html fetched
 // 2026-08-22 in a cleared Chrome tab after the plain-TLS probe was served the
 // challenge (time-varying; plain curl answered 403 the same day).
 const novelfullCompletedFixture = `<div><h3>Status:</h3><a href="/status/Completed">Completed</a></div>`
 // Trimmed from https://novelfull.com/a-cunning-pervert-in-the-cultivation-world.html
 // fetched 2026-08-22 the same way.
 const novelfullOngoingFixture = `<div><h3>Status:</h3><a href="/status/Ongoing">Ongoing</a></div>`
 // Trimmed from the JSON-LD block in the head of
 // https://lightnovelworld.net/novel/a-will-eternal/ fetched 2026-08-22. The
 // block sits ahead of the wpdiscuz thread, so the predicate reads the whole
 // body and needs no comment marker, unlike lnwLatestChapter.
 const lnwCompletedFixture = `<script type="application/ld+json">{
    "@context": "https://schema.org",
    "@type": "Book",
    "name": "A Will Eternal",
    "creativeWorkStatus": "https://schema.org/CompletedActionStatus"
 }</script>`
 // Trimmed from
 // https://lightnovelworld.net/novel/all-jobs-and-classes-i-just-wanted-one-skill-not-them-all/
 // fetched 2026-08-22. Same block, ongoing value.
 const lnwOngoingFixture = `<script type="application/ld+json">{
    "@context": "https://schema.org",
    "@type": "Book",
    "name": "All Jobs and Classes I Just Wanted One Skill Not Them All",
    "creativeWorkStatus": "https://schema.org/ActiveActionStatus"
 }</script>`
 // Trimmed from https://asurascans.com/comics/chronicles-of-the-demon-faction-f886a8af
 // (redirected to ...-00dcbf97) on 2026-08-10.
 const asuraCoverFixture = `<meta property="og:image" content="https://cdn.asurascans.com/asura-images/covers/chronicles-of-the-demon-faction.d4dcb8.webp">`
@@ -571,178 +473,3 @@ func TestLatestChapterFrom(t *testing.T) {
 		})
 	}
 }
 func TestSiteCompletedFrom(t *testing.T) {
 	const asuraURL = "https://asurascans.com/comics/solo-leveling-b60d532c"
 	const demonicURL = "https://demonicscans.org/manga/Solo-Leveling"
 	const comixURL = "https://comix.to/title/q77m-countach"
 	const kaganeURL = "https://kagane.to/series/019f84bc-9ba0-7ed9-86f5-8b905ec7c28b"
 	const novelfullURL = "https://novelfull.com/reverend-insanity.html"
 	const lnwURL = "https://lightnovelworld.net/novel/a-will-eternal/"
 	tests := []struct {
 		name      string
 		site      string
 		seriesURL string
 		body      string
 		want      bool
 	}{
 		{
 			name: "asura completed via escaped props status",
 			site: "asura", seriesURL: asuraURL, body: asuraCompletedFixture,
 			want: true,
 		},
 		{
 			name:      "asura ongoing value is not completed",
 			site:      "asura",
 			seriesURL: "https://asurascans.com/comics/chronicles-of-the-demon-faction-f886a8af",
 			body:      asuraOngoingFixture,
 			want:      false,
 		},
 		{
 			name: "asura with the status key removed",
 			site: "asura", seriesURL: asuraURL,
 			body: strings.ReplaceAll(asuraCompletedFixture, `&quot;status&quot;:[0,&quot;completed&quot;]`, ""),
 			want: false,
 		},
 		{
 			name: "asura challenge page",
 			site: "asura", seriesURL: asuraURL, body: challengeFixture,
 			want: false,
 		},
 		{
 			name: "demonic completed info-block pair",
 			site: "demonic", seriesURL: demonicURL, body: demonicCompletedFixture,
 			want: true,
 		},
 		{
 			name:      "demonic ongoing value is not completed",
 			site:      "demonic",
 			seriesURL: "https://demonicscans.org/manga/Catastrophic-Necromancer",
 			body:      demonicOngoingFixture,
 			want:      false,
 		},
 		{
 			name: "demonic with the value li removed",
 			site: "demonic", seriesURL: demonicURL,
 			body: strings.ReplaceAll(demonicCompletedFixture, "<li>Completed</li>", ""),
 			want: false,
 		},
 		{
 			name:      "comix recommended finished does not count",
 			site:      "comix",
 			seriesURL: "https://comix.to/title/n8we-dungeons-and-crayons",
 			body:      comixOngoingFixture,
 			want:      false,
 		},
 		{
 			name:      "comix detail finished wins over a finished recommended strip",
 			site:      "comix",
 			seriesURL: comixURL,
 			body:      comixCompletedFixture,
 			want:      true,
 		},
 		{
 			name: "comix with the detail status removed",
 			site: "comix", seriesURL: comixURL,
 			body: strings.ReplaceAll(comixCompletedFixture, `"status":"finished",`, ""),
 			want: false,
 		},
 		{
 			name: "comix challenge page",
 			site: "comix", seriesURL: comixURL, body: challengeFixture,
 			want: false,
 		},
 		{
 			name:      "kagane publication Completed",
 			site:      "kagane",
 			seriesURL: "https://kagane.to/series/019c29c3-5abd-70e6-9efc-1f1f22d839f6",
 			body:      kaganeCompletedFixture,
 			want:      true,
 		},
 		{
 			name: "kagane upload Completed does not count",
 			site: "kagane", seriesURL: kaganeURL, body: kaganeDivergentFixture,
 			want: false,
 		},
 		{
 			name: "kagane ongoing values are not completed",
 			site: "kagane", seriesURL: kaganeURL, body: kaganeOngoingFixture,
 			want: false,
 		},
 		{
 			name: "kagane with publication_status removed",
 			site: "kagane", seriesURL: kaganeURL,
 			body: strings.ReplaceAll(kaganeCompletedFixture, `"publication_status":"Completed",`, ""),
 			want: false,
 		},
 		{
 			name: "kagane challenge page",
 			site: "kagane", seriesURL: kaganeURL, body: challengeFixture,
 			want: false,
 		},
 		{
 			name:      "novelfull status link Completed",
 			site:      "novelfull",
 			seriesURL: novelfullURL,
 			body:      novelfullCompletedFixture,
 			want:      true,
 		},
 		{
 			name:      "novelfull ongoing link is not completed",
 			site:      "novelfull",
 			seriesURL: "https://novelfull.com/a-cunning-pervert-in-the-cultivation-world.html",
 			body:      novelfullOngoingFixture,
 			want:      false,
 		},
 		{
 			name: "novelfull with the status link removed",
 			site: "novelfull", seriesURL: novelfullURL,
 			body: strings.ReplaceAll(novelfullCompletedFixture, `<a href="/status/Completed">Completed</a>`, ""),
 			want: false,
 		},
 		{
 			name: "novelfull challenge page",
 			site: "novelfull", seriesURL: novelfullURL, body: challengeFixture,
 			want: false,
 		},
 		{
 			name:      "lightnovelworld JSON-LD CompletedActionStatus",
 			site:      "lightnovelworld",
 			seriesURL: lnwURL,
 			body:      lnwCompletedFixture,
 			want:      true,
 		},
 		{
 			name:      "lightnovelworld ActiveActionStatus is not completed",
 			site:      "lightnovelworld",
 			seriesURL: "https://lightnovelworld.net/novel/all-jobs-and-classes-i-just-wanted-one-skill-not-them-all/",
 			body:      lnwOngoingFixture,
 			want:      false,
 		},
 		{
 			name: "lightnovelworld with creativeWorkStatus removed",
 			site: "lightnovelworld", seriesURL: lnwURL,
 			body: strings.ReplaceAll(lnwCompletedFixture, `"creativeWorkStatus": "https://schema.org/CompletedActionStatus"`, ""),
 			want: false,
 		},
 		{
 			name: "lightnovelworld challenge page",
 			site: "lightnovelworld", seriesURL: lnwURL, body: challengeFixture,
 			want: false,
 		},
 		{
 			name: "unknown site",
 			site: "mangadex", seriesURL: "https://mangadex.org/title/x", body: asuraCompletedFixture,
 			want: false,
 		},
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			if got := siteCompletedFrom(tt.site, tt.seriesURL, tt.body); got != tt.want {
 				t.Errorf("siteCompletedFrom(%q, %q, body) = %v, want %v", tt.site, tt.seriesURL, got, tt.want)
 			}
 		})
 	}
 }
@@ -1,122 +0,0 @@
 // Package notify posts owner-notice embeds to a Discord webhook. It is
 // deliberately small and stdlib-only: one POST of a JSON body needs no
 // Discord library, and the path imports nothing of this repo's session or
 // OAuth packages — that independence is why a webhook was chosen over a bot
 // (issue #171, AC9).
 package notify
 import (
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"strings"
 	"time"
 	"bookmarkmanager/backend/internal/latest"
 )
 // dangerColor is the dark design branch's --danger, #cf5c4d = 13589581. The
 // integer is unreadable, so a future edit will otherwise "fix" it — do not:
 // --ember means new chapter only, and a fault wearing ember would tell the
 // owner a stall is a release. This is the one colour a fault wears.
 const dangerColor = 13589581
 // Client posts owner notices to one Discord webhook. The webhook address is a
 // secret in the class of TOKEN_KEY: it is never logged, never rendered, and
 // never carried in a returned error, which the poller logs.
 type Client struct {
 	webhookURL string
 	baseURL    string // the deployment's public origin; embed URLs resolve against it
 	http       *http.Client
 }
 // New returns a Client posting to webhookURL. baseURL is the deployment's
 // public origin (Config.PublicBaseURL); the embed's deep-linked title is
 // built from it.
 func New(webhookURL, baseURL string) *Client {
 	return &Client{
 		webhookURL: webhookURL,
 		baseURL:    strings.TrimSuffix(baseURL, "/"),
 		http:       &http.Client{Timeout: 10 * time.Second},
 	}
 }
 // Notify posts one owner notice as a Discord embed: the danger colour, the
 // subject as a deep-linked title, the sentence as the description, the pass
 // time as the timestamp and the machine word in the footer. The send is
 // wrapped in a deadline so a hanging Discord cannot hold a poller Lane. On
 // failure the error carries no part of the webhook address (the poller logs
 // it), and the caller leaves the suppression row unwritten so the next pass
 // retries while the condition holds.
 func (c *Client) Notify(ctx context.Context, f latest.Fault, sentence, href string) error {
 	ctx, cancel := context.WithTimeout(ctx, 10*time.Second)
 	defer cancel()
 	body, err := json.Marshal(c.payload(f, sentence, href))
 	if err != nil {
 		return fmt.Errorf("owner notice: marshal: %w", err)
 	}
 	req, err := http.NewRequestWithContext(ctx, http.MethodPost, c.webhookURL, strings.NewReader(string(body)))
 	if err != nil {
 		return errors.New("owner notice: build request")
 	}
 	req.Header.Set("Content-Type", "application/json")
 	resp, err := c.http.Do(req)
 	if err != nil {
 		// The transport error embeds the webhook address; the address is a
 		// secret in the class of TOKEN_KEY and the poller logs this error.
 		return errors.New("owner notice: send failed")
 	}
 	defer resp.Body.Close()
 	// Cap the read: a Discord error page is enough, and draining the body
 	// lets the connection be reused.
 	io.Copy(io.Discard, io.LimitReader(resp.Body, 4096))
 	if resp.StatusCode < 200 || resp.StatusCode > 299 {
 		return fmt.Errorf("owner notice: webhook status %d", resp.StatusCode)
 	}
 	return nil
 }
 // payload is the webhook body: one embed and nothing else. No fields, no
 // thumbnail, no author block — the wire shape is what Discord reads.
 func (c *Client) payload(f latest.Fault, sentence, href string) webhookPayload {
 	return webhookPayload{Embeds: []embed{{
 		Color:       dangerColor,
 		Title:       subject(f),
 		URL:         c.baseURL + href,
 		Description: sentence,
 		Timestamp:   time.UnixMilli(f.Since).UTC().Format(time.RFC3339),
 		Footer:      embedFooter{Text: f.Condition},
 	}}}
 }
 // subject renders the embed's title: the Site the fault is about, with the
 // machine word so the title needs no per-condition wording here — #172's
 // conditions pass different sentences, not a different builder. For a fault
 // that is not one Site's, the machine word stands alone.
 func subject(f latest.Fault) string {
 	if f.Site == "" {
 		return f.Condition
 	}
 	return f.Site + ": " + f.Condition
 }
 type webhookPayload struct {
 	Embeds []embed `json:"embeds"`
 }
 type embed struct {
 	Color       int         `json:"color"`
 	Title       string      `json:"title"`
 	URL         string      `json:"url"`
 	Description string      `json:"description"`
 	Timestamp   string      `json:"timestamp"`
 	Footer      embedFooter `json:"footer"`
 }
 type embedFooter struct {
 	Text string `json:"text"`
 }
@@ -1,100 +0,0 @@
 package notify_test
 import (
 	"context"
 	"encoding/json"
 	"net/http"
 	"net/http/httptest"
 	"strings"
 	"testing"
 	"time"
 	"bookmarkmanager/backend/internal/latest"
 	"bookmarkmanager/backend/internal/notify"
 )
 // TestNotifyEmbedShape pins the wire shape Discord actually reads: one embed
 // in the danger colour with the subject as a deep-linked title built from the
 // base URL, the sentence as the description, the pass time as an RFC3339
 // timestamp, the machine word in the footer, and no fields grid (nor
 // thumbnail, nor author block) at all. The webhook is a local server, so no
 // test can reach Discord.
 func TestNotifyEmbedShape(t *testing.T) {
 	var body map[string]any
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if ct := r.Header.Get("Content-Type"); ct != "application/json" {
 			t.Errorf("Content-Type = %q, want application/json", ct)
 		}
 		defer r.Body.Close()
 		if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
 			t.Errorf("decode request body: %v", err)
 		}
 		w.WriteHeader(http.StatusNoContent)
 	}))
 	defer srv.Close()
 	passTime := time.UnixMilli(5_000_000).UTC()
 	c := notify.New(srv.URL, "https://bookmarks.test/")
 	err := c.Notify(context.Background(),
 		latest.Fault{Condition: latest.ConditionStall, Site: "comix", Since: passTime.UnixMilli()},
 		"sentence", "/admin/lanes")
 	if err != nil {
 		t.Fatalf("Notify: %v", err)
 	}
 	embeds, ok := body["embeds"].([]any)
 	if !ok || len(embeds) != 1 {
 		t.Fatalf("embeds = %#v, want exactly one embed", body["embeds"])
 	}
 	embed, ok := embeds[0].(map[string]any)
 	if !ok {
 		t.Fatalf("embed = %#v, want an object", embeds[0])
 	}
 	if color, ok := embed["color"].(float64); !ok || int(color) != 13589581 {
 		t.Fatalf("color = %#v, want 13589581 (--danger #cf5c4d)", embed["color"])
 	}
 	if url := embed["url"]; url != "https://bookmarks.test/admin/lanes" {
 		t.Fatalf("url = %#v, want the title deep-linked off the base URL", url)
 	}
 	if desc := embed["description"]; desc != "sentence" {
 		t.Fatalf("description = %#v, want the sentence", desc)
 	}
 	footer, ok := embed["footer"].(map[string]any)
 	if !ok || footer["text"] != latest.ConditionStall {
 		t.Fatalf("footer = %#v, want the machine word in the footer", embed["footer"])
 	}
 	ts, ok := embed["timestamp"].(string)
 	if !ok {
 		t.Fatalf("timestamp = %#v, want an RFC3339 string", embed["timestamp"])
 	}
 	parsed, err := time.Parse(time.RFC3339, ts)
 	if err != nil || !parsed.Equal(passTime) {
 		t.Fatalf("timestamp = %q, want %s (the pass time, RFC3339)", ts, passTime.Format(time.RFC3339))
 	}
 	for _, banned := range []string{"fields", "thumbnail", "author"} {
 		if _, ok := embed[banned]; ok {
 			t.Fatalf("embed has %q, want it absent (no field grid, no thumbnail, no author block)", banned)
 		}
 	}
 }
 // A non-2xx answer is an error the caller logs, and the error never carries
 // the webhook address — a secret in the class of TOKEN_KEY, and the poller
 // logs every notify error.
 func TestNotifyNon2xxIsErrorWithoutTheAddress(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		w.WriteHeader(http.StatusInternalServerError)
 	}))
 	defer srv.Close()
 	c := notify.New(srv.URL, "https://bookmarks.test")
 	err := c.Notify(context.Background(),
 		latest.Fault{Condition: latest.ConditionStall, Site: "comix", Since: 5_000_000},
 		"sentence", "/admin/lanes")
 	if err == nil {
 		t.Fatal("Notify = nil, want an error for a 500")
 	}
 	if strings.Contains(err.Error(), srv.URL) {
 		t.Fatalf("error %q leaks the webhook address", err)
 	}
 }
@@ -7,14 +7,10 @@ import (
 	"strings"
 )
-// Series filter names (issue #140): the seven repair filters are ordered
+// Series filter names (issue #140), ordered permanent-then-fixable — the
-// permanent-then-fixable — the repairs nothing will ever undo first, the
+// repairs nothing will ever undo first, the ones a Poll can make right after.
-// ones a Poll can make right after. SeriesFilterFinished and
+// A name is the repair a row needs, not the SQL that finds it; the values are
-// SeriesFilterSiteCompleted are not part of that ordering: a finished
+// the wire form the Series list URL carries (#142). "all" is the absent and
 // Series is a deliberate state and a Site-completed one is the Site's own
 // marker, not repairs, so the pair rides the tail, informational. A name is
 // the repair a row needs, not the SQL that finds it; the values are the
 // wire form the Series list URL carries (#142). "all" is the absent and
 // unknown case: every Series.
 const (
 	SeriesFilterAll          = "all"
@@ -25,22 +21,17 @@ const (
 	SeriesFilterStale        = "stale"
 	SeriesFilterNoCover      = "no_cover"
 	SeriesFilterReaderReport = "reader_report"
 	SeriesFilterFinished      = "finished"
 	SeriesFilterSiteCompleted = "site_completed"
 	SeriesFilterFailing       = "failing"
 	SeriesFilterUnverified    = "unverified"
 )
-// SeriesFilter is one named filter predicate over the whole library. Site
+// SeriesFilter is one named hygiene predicate over the whole library. Site
 // and Kind narrow the row read; Name picks the predicate; Cutoff is the
-// staleness boundary the age-based filters — "stale" and the failing pair —
+// staleness boundary the "stale" filter compares against, supplied by the
-// compare against, supplied by the caller's clock — the store has no clock;
+// caller's clock — the store has no clock; Page is 1-based.
 // Page is 1-based.
 type SeriesFilter struct {
 	Site   string // "" = every Site
 	Kind   string // "" = both library buckets' series
 	Name   string // one of the SeriesFilter* constants; "" = SeriesFilterAll
-	Cutoff int64  // unix ms; the age-based filters read it, the store never does
+	Cutoff int64  // unix ms; "stale" reads it, the store never does
 	Page   int    // 1-based page of the row read; default 1
 }
@@ -51,7 +42,7 @@ type SeriesFilter struct {
 // and only the anonymous boolean in raisedByReaderAnswer crosses it.
 const adminSeriesColumns = `s.site, s.series_id, s.title, s.series_url, s.cover_address,
 	s.kind, s.latest_chapter, s.latest_chapter_num, s.latest_checked_at, s.force_poll_at,
-	s.latest_corrected_at, s.finished_at, s.site_completed_at`
+	s.latest_corrected_at`
 // raisedByReaderAnswer answers "did a Reader's report set this number" without
 // naming which Reader. Kept apart from adminSeriesColumns so the column list —
@@ -60,12 +51,6 @@ const adminSeriesColumns = `s.site, s.series_id, s.title, s.series_url, s.cover_
 // Reader behind them.
 const raisedByReaderAnswer = `(s.latest_raised_by IS NOT NULL) AS raised_by_reader`
 // failureAnswer is the poll-failures row's answer (issue #165), kept apart
 // from adminSeriesColumns like raisedByReaderAnswer: outcome and failing_since
 // are not Series columns, and the COALESCE keeps the row scannable when the
 // LEFT JOIN finds no failure row.
 const failureAnswer = `COALESCE(f.outcome, ''), COALESCE(f.failing_since, 0)`
 // seriesPageSize is the row read's page length. The tie-break in the query's
 // ORDER BY is what makes this a stable page boundary — see SeriesPage.
 const seriesPageSize = 50
@@ -95,19 +80,7 @@ type AdminSeries struct {
 	LatestCorrectedAt int64
 	ReaderCount       int
 	RaisedByReader    bool // a Reader's report set LatestChapterNum
-	// FailureOutcome is the outcome word of the Series' standing failure, ""
+
 	// when no failure row stands. FailingSince is when the run of failures
 	// began, zero with no row. Both come from the LEFT JOIN, not the Series
 	// row (issue #165: the row's existence is the state).
 	FailureOutcome string
 	FailingSince   int64
 	// FinishedAt is the owner's finish stamp: unix ms, zero while the Series is
 	// not finished — the same shape as the Correction stamp, and its own undo.
 	FinishedAt int64
 	// SiteCompletedAt is when the last successful Poll read saw the Site's own
 	// completed value, zero meaning it did not (issue #168). The Site's marker,
 	// never a Lifecycle decision: the owner's Finish is the only retirement.
 	SiteCompletedAt int64
 }
 // SeriesPage is one page of the owner's filtered Series list plus the count
@@ -140,28 +113,10 @@ func (a AdminSeries) Key() string { return a.Site + ":" + a.SeriesID }
 // The WHERE set is: no URL (an empty URL only — the host-failing-the-fetch-
 // gate case is invisible to SQL, needs the Site registry in Go, and belongs to
 // a later repair), never-read-a-chapter and never-checked as disjoint halves
-// (non-zero versus zero check stamp), stale, no cover, finished (the
+// (non-zero versus zero check stamp), stale, no cover, and Reader-report.
 // retirement stamp, read directly), site completed (the Site's marker, read
 // directly), Reader-report, and the failing pair — failing (the failure row
 // exists, a chapter exists, and failing_since is past the cutoff) and
 // unverified (the Reader-attributed subset of failing).
 // failing's chapter IS NOT NULL is the exact complement of never-read-a-
 // chapter's IS NULL half, so the two are disjoint by construction.
 // no_readers is the one HAVING predicate: it is the orphan test, an aggregate
 // over the LEFT JOIN, where a bare WHERE has no row to test.
 //
 // The clock-versus-outcome split decides which predicates exclude finished
 // Series (`s.finished_at = 0` in each of the five): the clock-driven ones —
 // never-checked, stale, no-chapter, no-cover — keep ticking after the last
 // Poll, so they would report a retired row as a problem no Poll is coming to
 // fix; site-completed's stamp is the Site's, and it keeps standing after the
 // owner retires the row, so a finished Series would be reported as work
 // nobody is going to do. The outcome-driven ones — no-URL, no-readers,
 // Reader-report, failing, unverified — read stored facts that simply stop
 // arriving, so a finished Series needing a genuine repair still shows up
 // under them. The failing pair carries no finished guard for exactly that
 // contrast: a failure row is a stored outcome, not a ticking clock.
 //
 // stale is the checked-but-old half of the stamp partition — because the
 // verdict line wants "not checked in twelve hours" as one figure, and a never
 // checked Series is already counted on its own "waiting"/never-checked
@@ -178,26 +133,16 @@ func adminFilter(f SeriesFilter) (where, having string, args []any, err error) {
 	case SeriesFilterNoURL:
 		clauses = append(clauses, `s.series_url = ''`)
 	case SeriesFilterNoChapter:
-		clauses = append(clauses, `s.latest_checked_at <> 0 AND s.latest_chapter_num IS NULL AND s.finished_at = 0`)
+		clauses = append(clauses, `s.latest_checked_at <> 0 AND s.latest_chapter_num IS NULL`)
 	case SeriesFilterNeverChecked:
-		clauses = append(clauses, `s.latest_checked_at = 0 AND s.finished_at = 0`)
+		clauses = append(clauses, `s.latest_checked_at = 0`)
 	case SeriesFilterStale:
-		clauses = append(clauses, `s.latest_checked_at > 0 AND s.latest_checked_at < $`+strconv.Itoa(len(args)+1)+` AND s.finished_at = 0`)
+		clauses = append(clauses, `s.latest_checked_at > 0 AND s.latest_checked_at < $`+strconv.Itoa(len(args)+1))
 		args = append(args, f.Cutoff)
 	case SeriesFilterNoCover:
-		clauses = append(clauses, `s.cover_address = '' AND s.finished_at = 0`)
+		clauses = append(clauses, `s.cover_address = ''`)
 	case SeriesFilterReaderReport:
 		clauses = append(clauses, `s.latest_raised_by IS NOT NULL`)
 	case SeriesFilterFailing:
 		clauses = append(clauses, `f.site IS NOT NULL AND s.latest_chapter_num IS NOT NULL AND f.failing_since < $`+strconv.Itoa(len(args)+1))
 		args = append(args, f.Cutoff)
 	case SeriesFilterUnverified:
 		clauses = append(clauses, `f.site IS NOT NULL AND s.latest_chapter_num IS NOT NULL AND f.failing_since < $`+strconv.Itoa(len(args)+1)+` AND s.latest_raised_by IS NOT NULL`)
 		args = append(args, f.Cutoff)
 	case SeriesFilterFinished:
 		clauses = append(clauses, `s.finished_at > 0`)
 	case SeriesFilterSiteCompleted:
 		clauses = append(clauses, `s.site_completed_at > 0 AND s.finished_at = 0`)
 	case SeriesFilterNoReaders:
 		having = `HAVING COUNT(b.reader_id) = 0`
 	default:
@@ -212,9 +157,9 @@ func adminFilter(f SeriesFilter) (where, having string, args []any, err error) {
 // SeriesPage returns one page of the Series matching the filter, least
 // recently checked first. The LEFT JOIN to Bookmarks is what surfaces the
 // orphans that hygiene has to find — an inner join would hide them, exactly
-// as the Lane's join does. Every bookmark keeps its Series polled now that
+// as the Lane's join does. ReaderCount is a plain count of every Bookmark on
-// finished is a Series flag, so this plain ReaderCount agrees with the Lane
+// the Series, which knowingly disagrees with the two Lane queries for as long
-// queries (issue #157).
+// as the finished lifecycle bucket exists (#140).
 //
 // The tie-break is mandatory, not decorative: every unpollable Series shares a
 // zero check stamp, so ordering on that column alone gives no stable page
@@ -243,18 +188,15 @@ func (s *Store) SeriesPage(f SeriesFilter) (SeriesPage, error) {
 	base := len(args)
 	args = append(args, seriesPageSize, seriesPageSize*(f.Page-1))
 	rows, err := s.db.Query(`
-		SELECT `+adminSeriesColumns+`, `+raisedByReaderAnswer+`, `+failureAnswer+`,
+		SELECT `+adminSeriesColumns+`, `+raisedByReaderAnswer+`,
 		       COUNT(b.reader_id) AS reader_count,
 		       COUNT(*) OVER () AS filtered_total
 		FROM series s
 		LEFT JOIN bookmarks b ON b.site = s.site AND b.series_id = s.series_id
 		LEFT JOIN poll_failures f ON f.site = s.site AND f.series_id = s.series_id
 		`+where+`
 		GROUP BY s.site, s.series_id, s.title, s.series_url, s.cover_address,
 		         s.kind, s.latest_chapter, s.latest_chapter_num, s.latest_checked_at,
-		         s.force_poll_at, s.latest_corrected_at, s.finished_at, s.site_completed_at,
+		         s.force_poll_at, s.latest_corrected_at, s.latest_raised_by
 		         s.latest_raised_by,
 		         f.outcome, f.failing_since
 		`+having+`
 		ORDER BY s.latest_checked_at, s.site, s.series_id
 		LIMIT $`+strconv.Itoa(base+1)+` OFFSET $`+strconv.Itoa(base+2), args...)
@@ -293,7 +235,6 @@ func (s *Store) SeriesShapes(f SeriesFilter) ([]SiteSeriesShape, error) {
 			SELECT s.site, s.kind
 			FROM series s
 			LEFT JOIN bookmarks b ON b.site = s.site AND b.series_id = s.series_id
 			LEFT JOIN poll_failures f ON f.site = s.site AND f.series_id = s.series_id
 			`+where+`
 			GROUP BY s.site, s.series_id, s.kind
 			`+having+`
@@ -316,11 +257,11 @@ func (s *Store) SeriesShapes(f SeriesFilter) ([]SiteSeriesShape, error) {
 	return out, rows.Err()
 }
-// scanAdminSeries reads one row in adminSeriesColumns + raisedByReaderAnswer +
+// scanAdminSeries reads one row in adminSeriesColumns + raisedByReaderAnswer
-// failureAnswer order, plus the query's reader_count and filtered_total
+// order, plus the query's reader_count and filtered_total columns, and returns
-// columns, and returns the window total alongside the row. latest_chapter_num
+// the window total alongside the row. latest_chapter_num is NULL until first
-// is NULL until first captured — the "never read a chapter" state. The
+// captured — the "never read a chapter" state. The Sighting-raiser column is
-// Sighting-raiser column is never among the scanned columns.
+// never among the scanned columns.
 func scanAdminSeries(scan func(...any) error) (AdminSeries, int, error) {
 	var (
 		a                AdminSeries
@@ -330,8 +271,8 @@ func scanAdminSeries(scan func(...any) error) (AdminSeries, int, error) {
 	if err := scan(
 		&a.Site, &a.SeriesID, &a.Title, &a.SeriesURL, &a.CoverAddress,
 		&a.Kind, &a.LatestChapter, &latestChapterNum, &a.LatestCheckedAt,
-		&a.ForcePollAt, &a.LatestCorrectedAt, &a.FinishedAt, &a.SiteCompletedAt,
+		&a.ForcePollAt, &a.LatestCorrectedAt,
-		&a.RaisedByReader, &a.FailureOutcome, &a.FailingSince, &a.ReaderCount, &total,
+		&a.RaisedByReader, &a.ReaderCount, &total,
 	); err != nil {
 		return AdminSeries{}, 0, err
 	}
@@ -20,7 +20,6 @@ type seriesSeed struct {
 	latestNum *float64
 	bookmarks int  // readers that hold it; 0 = orphan
 	raisedBy  bool // a Reader's report is attributed as the raiser
 	siteCompletedAt int64 // the Site's own marker (issue #168), 0 = not set
 }
 // seedAdminSeries inserts one series row and its bookmarks (owner first, then
@@ -40,10 +39,10 @@ func seedAdminSeries(t *testing.T, s *Store, seed seriesSeed) {
 	}
 	if _, err := s.db.Exec(`
 		INSERT INTO series (site, series_id, title, kind, series_url, cover_address,
-		                    latest_checked_at, latest_chapter, latest_chapter_num, site_completed_at)
+		                    latest_checked_at, latest_chapter, latest_chapter_num)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
 		site, seriesID, "Title of "+seed.key, seed.kind, seed.url, seed.cover,
-		seed.checkedAt, latestChapter, seed.latestNum, seed.siteCompletedAt); err != nil {
+		seed.checkedAt, latestChapter, seed.latestNum); err != nil {
 		t.Fatalf("seed series %q: %v", seed.key, err)
 	}
 	for i := range seed.bookmarks {
@@ -129,85 +128,6 @@ func TestAdminSeriesFilters(t *testing.T) {
 	}
 }
 // A finished Series is the owner's deliberate state, not a problem a Poll
 // will fix: the four clock-driven hygiene predicates exclude it (their
 // stamps stop advancing at the last Poll, so without the guard a retired row
 // is reported forever), the three outcome-driven ones still include it, and
 // the finished filter returns exactly the retired rows.
 func TestAdminFinishedSeriesFilters(t *testing.T) {
 	s := newTestStore(t)
 	// Each fin-* row is shaped to trip exactly one predicate if its guard
 	// fails: checked-but-old for stale, a zero stamp for never-checked, a
 	// stamp with no chapter for no-chapter, an empty cover for no-cover, and
 	// the unguarded three shaped to trip their own. A healthy, unfinished
 	// neighbour keeps the exclusion checks honest: a filter that regressed to
 	// matching nothing would pass a bare "no finished rows" assertion.
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-stale", url: "u", cover: "c", checkedAt: 2000, latestNum: new(4.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-neverchecked", url: "u", cover: "c", checkedAt: 0, latestNum: new(4.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-nochapter", url: "u", cover: "c", checkedAt: 9000, bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-nocover", url: "u", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-nourl", url: "", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-orphan", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 0})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-report", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1, raisedBy: true})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:healthy", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1})
 	finished := []string{
 		"asura:fin-stale", "asura:fin-neverchecked", "asura:fin-nochapter",
 		"asura:fin-nocover", "asura:fin-nourl", "asura:fin-orphan", "asura:fin-report",
 	}
 	for _, key := range finished {
 		site, id, _ := strings.Cut(key, ":")
 		if err := s.SetSeriesFinished(site, id, 1000); err != nil {
 			t.Fatalf("finish %s: %v", key, err)
 		}
 	}
 	cases := []struct {
 		name string
 		f    SeriesFilter
 		want []string
 	}{
 		{"stale excludes finished", SeriesFilter{Name: SeriesFilterStale, Cutoff: 5000}, nil},
 		{"never checked excludes finished", SeriesFilter{Name: SeriesFilterNeverChecked}, nil},
 		{"no chapter excludes finished", SeriesFilter{Name: SeriesFilterNoChapter}, nil},
 		{"no cover excludes finished", SeriesFilter{Name: SeriesFilterNoCover}, nil},
 		{"no url includes finished", SeriesFilter{Name: SeriesFilterNoURL}, []string{"asura:fin-nourl"}},
 		{"no readers includes finished", SeriesFilter{Name: SeriesFilterNoReaders}, []string{"asura:fin-orphan"}},
 		{"reader report includes finished", SeriesFilter{Name: SeriesFilterReaderReport}, []string{"asura:fin-report"}},
 		{"finished returns the retired rows", SeriesFilter{Name: SeriesFilterFinished}, finished},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			got := pageKeys(t, s, tc.f)
 			want := map[string]bool{}
 			for _, k := range tc.want {
 				want[k] = true
 			}
 			if len(got) != len(want) {
 				t.Fatalf("%+v returned %v, want exactly %v", tc.f, got, want)
 			}
 			for k := range want {
 				if !got[k] {
 					t.Fatalf("%+v dropped %q (got %v)", tc.f, k, got)
 				}
 			}
 		})
 	}
 	// The aggregate's finished total counts every retired row — the same
 	// predicate the Overview's finished figure is summed from.
 	shapes, err := s.SeriesShapes(SeriesFilter{Name: SeriesFilterFinished})
 	if err != nil {
 		t.Fatalf("SeriesShapes(finished): %v", err)
 	}
 	sum := 0
 	for _, sh := range shapes {
 		sum += sh.Total
 	}
 	if sum != len(finished) {
 		t.Fatalf("finished aggregate = %d, want %d", sum, len(finished))
 	}
 }
 // "Never read a chapter" and "never checked" are disjoint by construction:
 // the first requires a non-zero check stamp, the second a zero one. Over a
 // mix that should satisfy both, no row may be counted twice.
@@ -474,263 +394,3 @@ func TestAdminSeriesCarriesForcePollAt(t *testing.T) {
 		t.Fatalf("row = %+v, want ForcePollAt 5000", page.Rows)
 	}
 }
 // SetSeriesFinished is the owner's finish stamp write: finishing writes the
 // given ms, un-finishing writes zero — the one undo, the same shape as the
 // correction stamp. Touching a missing series is not an error: the row may
 // have been orphaned, and the caller's read decides what exists.
 func TestSetSeriesFinishedStampsAndClears(t *testing.T) {
 	s := newTestStore(t)
 	seedAdminSeries(t, s, seriesSeed{key: "asura:x", url: "u", checkedAt: 9000, bookmarks: 1})
 	if err := s.SetSeriesFinished("asura", "x", 42); err != nil {
 		t.Fatalf("SetSeriesFinished: %v", err)
 	}
 	var got int64
 	if err := s.db.QueryRow(
 		`SELECT finished_at FROM series WHERE site = 'asura' AND series_id = 'x'`).Scan(&got); err != nil {
 		t.Fatalf("read finished_at: %v", err)
 	}
 	if got != 42 {
 		t.Fatalf("finished_at = %d, want 42", got)
 	}
 	if err := s.SetSeriesFinished("asura", "x", 0); err != nil {
 		t.Fatalf("SetSeriesFinished un-finish: %v", err)
 	}
 	if err := s.db.QueryRow(
 		`SELECT finished_at FROM series WHERE site = 'asura' AND series_id = 'x'`).Scan(&got); err != nil {
 		t.Fatalf("read finished_at after un-finish: %v", err)
 	}
 	if got != 0 {
 		t.Fatalf("finished_at = %d, want 0 (un-finish writes zero)", got)
 	}
 	if err := s.SetSeriesFinished("asura", "ghost", 42); err != nil {
 		t.Fatalf("SetSeriesFinished missing: %v", err)
 	}
 }
 // The admin projection carries the finish stamp so the web layer can render
 // the finished state without a second read.
 func TestAdminSeriesCarriesFinishedAt(t *testing.T) {
 	s := newTestStore(t)
 	seedAdminSeries(t, s, seriesSeed{key: "asura:x", url: "u", checkedAt: 1000, bookmarks: 1})
 	if err := s.SetSeriesFinished("asura", "x", 5000); err != nil {
 		t.Fatalf("SetSeriesFinished: %v", err)
 	}
 	page, err := s.SeriesPage(SeriesFilter{})
 	if err != nil {
 		t.Fatalf("SeriesPage: %v", err)
 	}
 	if len(page.Rows) != 1 || page.Rows[0].FinishedAt != 5000 {
 		t.Fatalf("row = %+v, want FinishedAt 5000", page.Rows)
 	}
 }
 // The failing pair reads the failure row's age, not the Series row (issue
 // #165): failing requires the joined row, a Latest Chapter, and failing_since
 // past the cutoff — the same constant stale reads; unverified is the
 // Reader-attributed subset of the same test. A failure inside the window is
 // in neither — one bad fetch is not a fault to correct — and a Series that
 // never captured a chapter is never failing, the exact complement of
 // never-read-a-chapter's IS NULL half, so the two filters are disjoint by
 // construction. A finished failing Series still appears: this pair reads
 // stored outcomes, which simply stop arriving, and carries no finished guard.
 func TestAdminFailingAndUnverifiedFilters(t *testing.T) {
 	s := newTestStore(t)
 	const cutoff = 5000
 	seedAdminSeries(t, s, seriesSeed{key: "asura:failing", url: "u", cover: "c", checkedAt: 9000, latestNum: new(10.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:recent", url: "u", cover: "c", checkedAt: 9000, latestNum: new(9.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:nochapter", url: "u", cover: "c", checkedAt: 9000, bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:reader", url: "u", cover: "c", checkedAt: 9000, latestNum: new(8.0), bookmarks: 1, raisedBy: true})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:polled", url: "u", cover: "c", checkedAt: 9000, latestNum: new(7.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fin-failing", url: "u", cover: "c", checkedAt: 9000, latestNum: new(6.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:healthy", url: "u", cover: "c", checkedAt: 9000, latestNum: new(5.0), bookmarks: 1})
 	// Failure rows seed the run's start stamp; the cutoff decides the age.
 	for _, f := range []struct {
 		key, word string
 		since     int64
 	}{
 		{"asura:failing", "not_found", 2000},
 		{"asura:recent", "not_found", 9000},
 		{"asura:nochapter", "not_found", 2000},
 		{"asura:reader", "not_found", 2000},
 		{"asura:polled", "errors", 2000},
 		{"asura:fin-failing", "not_found", 2000},
 	} {
 		site, id, _ := strings.Cut(f.key, ":")
 		if err := s.RecordSeriesFailure(site, id, f.word, f.since); err != nil {
 			t.Fatalf("seed failure %s: %v", f.key, err)
 		}
 	}
 	if err := s.SetSeriesFinished("asura", "fin-failing", 1000); err != nil {
 		t.Fatalf("finish asura:fin-failing: %v", err)
 	}
 	cases := []struct {
 		name string
 		f    SeriesFilter
 		want []string
 	}{
 		{"failing", SeriesFilter{Name: SeriesFilterFailing, Cutoff: cutoff}, []string{"asura:failing", "asura:reader", "asura:polled", "asura:fin-failing"}},
 		{"unverified", SeriesFilter{Name: SeriesFilterUnverified, Cutoff: cutoff}, []string{"asura:reader"}},
 		{"never read a chapter", SeriesFilter{Name: SeriesFilterNoChapter}, []string{"asura:nochapter"}},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
 			got := pageKeys(t, s, tc.f)
 			want := map[string]bool{}
 			for _, k := range tc.want {
 				want[k] = true
 			}
 			if len(got) != len(want) {
 				t.Fatalf("%+v returned %v, want exactly %v", tc.f, got, want)
 			}
 			for k := range want {
 				if !got[k] {
 					t.Fatalf("%+v dropped %q (got %v)", tc.f, k, got)
 				}
 			}
 		})
 	}
 	// Disjointness: the failing pair and never-read-a-chapter are disjoint by
 	// the chapter column — IS NOT NULL here, IS NULL there — so no row may be
 	// counted under both.
 	failing := pageKeys(t, s, SeriesFilter{Name: SeriesFilterFailing, Cutoff: cutoff})
 	noChapter := pageKeys(t, s, SeriesFilter{Name: SeriesFilterNoChapter})
 	for k := range failing {
 		if noChapter[k] {
 			t.Fatalf("row %q matches both failing and never-read-a-chapter", k)
 		}
 	}
 	if failing["asura:nochapter"] {
 		t.Fatal("a Series with no chapter ever captured appears in failing")
 	}
 	if !noChapter["asura:nochapter"] {
 		t.Fatal("the no-chapter Series vanished from never-read-a-chapter")
 	}
 	// The aggregates count the same rows the lists do: the landing page's
 	// figures and the select's options come from these two passes.
 	for _, name := range []string{SeriesFilterFailing, SeriesFilterUnverified} {
 		shapes, err := s.SeriesShapes(SeriesFilter{Name: name, Cutoff: cutoff})
 		if err != nil {
 			t.Fatalf("SeriesShapes(%s): %v", name, err)
 		}
 		sum := 0
 		for _, sh := range shapes {
 			sum += sh.Total
 		}
 		want := len(pageKeys(t, s, SeriesFilter{Name: name, Cutoff: cutoff}))
 		if sum != want {
 			t.Fatalf("%s aggregate sum = %d, want %d (aggregate disagrees with row query)", name, sum, want)
 		}
 	}
 }
 // The projection carries the failure facts from the LEFT JOIN, not the
 // Series row: a failing Series reads back its outcome word and the stamp its
 // run began at; a Series with no failure row reads empty and zero. Nothing
 // new is projected from the Series row itself.
 func TestAdminFailureProjection(t *testing.T) {
 	s := newTestStore(t)
 	seedAdminSeries(t, s, seriesSeed{key: "asura:broken", url: "u", cover: "c", checkedAt: 9000, latestNum: new(9.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:fine", url: "u", cover: "c", checkedAt: 9000, latestNum: new(8.0), bookmarks: 1})
 	if err := s.RecordSeriesFailure("asura", "broken", "not_found", 2000); err != nil {
 		t.Fatalf("seed failure row: %v", err)
 	}
 	page, err := s.SeriesPage(SeriesFilter{})
 	if err != nil {
 		t.Fatalf("SeriesPage: %v", err)
 	}
 	byKey := map[string]AdminSeries{}
 	for _, a := range page.Rows {
 		byKey[a.Key()] = a
 	}
 	if byKey["asura:broken"].FailureOutcome != "not_found" || byKey["asura:broken"].FailingSince != 2000 {
 		t.Fatalf("broken row = %+v, want FailureOutcome not_found, FailingSince 2000", byKey["asura:broken"])
 	}
 	if byKey["asura:fine"].FailureOutcome != "" || byKey["asura:fine"].FailingSince != 0 {
 		t.Fatalf("fine row = %+v, want empty outcome and zero stamp", byKey["asura:fine"])
 	}
 }
 // The site-completed filter (issue #170) lists the Site's own marker as work
 // to work through, carrying the same finished guard the clock-driven
 // predicates gained: the Site's stamp keeps standing after the owner retires
 // the row, so a finished Series would be reported as work nobody is going to
 // do. A zero stamp never appears. Un-finishing puts the Series back in the
 // Poll query — the finished_at gate is #157's own, asserted through
 // DueForLatestCheck rather than re-derived here.
 func TestAdminSiteCompletedFilter(t *testing.T) {
 	s := newTestStore(t)
 	seedAdminSeries(t, s, seriesSeed{key: "asura:done", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1, siteCompletedAt: 5000})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:never", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:retired", url: "u", cover: "c", checkedAt: 0, latestNum: new(4.0), bookmarks: 1, siteCompletedAt: 5000})
 	seedAdminSeries(t, s, seriesSeed{key: "asura:healthy", url: "u", cover: "c", checkedAt: 9000, latestNum: new(4.0), bookmarks: 1})
 	if err := s.SetSeriesFinished("asura", "retired", 1000); err != nil {
 		t.Fatalf("finish asura:retired: %v", err)
 	}
 	got := pageKeys(t, s, SeriesFilter{Name: SeriesFilterSiteCompleted})
 	if len(got) != 1 || !got["asura:done"] {
 		t.Fatalf("site-completed returned %v, want only asura:done", got)
 	}
 	// The projection carries the stamp so the detail page can age it.
 	page, err := s.SeriesPage(SeriesFilter{Name: SeriesFilterSiteCompleted})
 	if err != nil {
 		t.Fatalf("SeriesPage(site_completed): %v", err)
 	}
 	if len(page.Rows) != 1 || page.Rows[0].SiteCompletedAt != 5000 {
 		t.Fatalf("row = %+v, want SiteCompletedAt 5000", page.Rows)
 	}
 	// The aggregate counts the same row: the landing figure and the select's
 	// option come from this pass, so they cannot disagree with the list.
 	shapes, err := s.SeriesShapes(SeriesFilter{Name: SeriesFilterSiteCompleted})
 	if err != nil {
 		t.Fatalf("SeriesShapes(site_completed): %v", err)
 	}
 	sum := 0
 	for _, sh := range shapes {
 		sum += sh.Total
 	}
 	if sum != 1 {
 		t.Fatalf("site-completed aggregate = %d, want 1", sum)
 	}
 	// Un-finishing puts the Series back in the Poll query: the due read's
 	// finished_at gate (issue #157) admits it again — asserted through the
 	// Lane's own read, not re-derived here.
 	due, err := s.DueForLatestCheck("asura", 1000, noCeiling)
 	if err != nil {
 		t.Fatalf("DueForLatestCheck: %v", err)
 	}
 	for _, sr := range due {
 		if sr.Key() == "asura:retired" {
 			t.Fatalf("a finished Series is still due for a Poll:\n%+v", due)
 		}
 	}
 	if err := s.SetSeriesFinished("asura", "retired", 0); err != nil {
 		t.Fatalf("un-finish asura:retired: %v", err)
 	}
 	due, err = s.DueForLatestCheck("asura", 1000, noCeiling)
 	if err != nil {
 		t.Fatalf("DueForLatestCheck after un-finish: %v", err)
 	}
 	found := false
 	for _, sr := range due {
 		if sr.Key() == "asura:retired" {
 			found = true
 		}
 	}
 	if !found {
 		t.Fatalf("un-finished Series is not due for a Poll:\n%+v", due)
 	}
 }
@@ -1,24 +0,0 @@
 -- finished_at is "the owner marked this Series finished" (#157): epoch ms,
 -- zero means not finished, and it doubles as the undo (write zero). The poll
 -- gate reads it — a Series is polled only while finished_at = 0 — never a
 -- bookmark's status.
 ALTER TABLE series ADD COLUMN finished_at bigint NOT NULL DEFAULT 0;
 -- Column first, seed second, flip third — the order is load-bearing: a seed
 -- that ran after the flip would read the buckets it just destroyed, declare
 -- nothing finished, and silently resume polling on Series nobody chose to
 -- resume. The seed mirrors the pre-cutover due gate exactly: a Series stays
 -- polled while any bookmark is outside the finished bucket, so a Series whose
 -- every bookmark sits in it is stamped, one click from being read again
 -- afterwards. The stamp is the only memory of the bucket the flip is about to
 -- erase.
 UPDATE series s SET finished_at = (EXTRACT(EPOCH FROM now()) * 1000)::bigint
 WHERE EXISTS (SELECT 1 FROM bookmarks b
                WHERE b.site = s.site AND b.series_id = s.series_id)
   AND NOT EXISTS (SELECT 1 FROM bookmarks b
                    WHERE b.site = s.site AND b.series_id = s.series_id
                      AND b.status <> 'finished');
 -- The Lifecycle bucket is gone; a finished bookmark is an archived one. The
 -- flip must come after the seed, which still reads the bucket.
 UPDATE bookmarks SET status = 'archived' WHERE status = 'finished';
@@ -1,4 +0,0 @@
 -- A 4xx other than the 403 refusal is the page being gone, not the Site being
 -- unwell; the pass log counts it separately so the Lanes page can say "not
 -- found" (#164). DEFAULT 0 keeps pre-existing rows readable.
 ALTER TABLE poll_passes ADD COLUMN not_found integer NOT NULL DEFAULT 0;
@@ -1,13 +0,0 @@
 -- One row per Series that is failing right now (ADR-0016): the row's
 -- existence is the failure state, failing_since ages the run of failures,
 -- and a correct read deletes the row. Keyed by the same (site, series_id)
 -- composite the rest of the system uses, with the cascade so deleting a
 -- Series takes its failure row and orphan removal stays a single statement.
 CREATE TABLE poll_failures (
 	site text NOT NULL,
 	series_id text NOT NULL,
 	outcome text NOT NULL,
 	failing_since bigint NOT NULL,
 	PRIMARY KEY (site, series_id),
 	FOREIGN KEY (site, series_id) REFERENCES series (site, series_id) ON DELETE CASCADE
 );
@@ -1,4 +0,0 @@
 -- When the last successful Poll read saw the Site's own completed value
 -- (#168): epoch-ms, zero meaning it did not. DEFAULT 0 keeps pre-existing
 -- rows readable.
 ALTER TABLE series ADD COLUMN site_completed_at bigint NOT NULL DEFAULT 0;
@@ -1,12 +0,0 @@
 -- Owner notices (issue #171): one row per episode, remembered only as "the
 -- owner was told". The row's presence is the whole state — the poller checks
 -- it before sending, writes it after a successful send, and clears it when
 -- the condition no longer holds. site is '' for a fault that is not one
 -- Site's; the composite primary key is what makes the row a lock against a
 -- second message for the same episode.
 CREATE TABLE owner_notices (
 	condition text NOT NULL,
 	site text NOT NULL,
 	notified_at bigint NOT NULL,
 	PRIMARY KEY (condition, site)
 );
@@ -47,16 +47,13 @@ type Bookmark struct {
 	LatestChapter    string   `json:"latest_chapter"`
 	LatestChapterNum *float64 `json:"latest_chapter_num"` // nil until first captured
 	UpdatedAt        int64    `json:"updated_at"`         // unix ms; see Upsert
-	// Status is the lifecycle bucket: reading or archived.
+	// Status is the lifecycle bucket: reading, archived, or finished.
-	// Archived series stay polled for new chapters.
+	// Archived series stay polled for new chapters; finished ones do not.
 	// Empty on the way in means "no opinion" — see Upsert.
 	Status string `json:"status"`
 	// Kind is the library bucket: manga or novel. Empty on the way in means
 	// "no opinion" — see Upsert.
 	Kind string `json:"kind"`
 	// Finished is the owner's retirement of the Series, derived: the flag is a
 	// Series fact and a client cannot write it — see Upsert.
 	Finished bool `json:"finished"`
 }
 // Series is one distinct work, shared by every bookmark that tracks it. It is
@@ -84,10 +81,6 @@ type Series struct {
 	LatestChapter    string
 	LatestChapterNum *float64 // nil until first captured
 	LatestCheckedAt  int64    // unix ms; see MarkLatestChecked
 	// SiteCompletedAt is when the last successful Poll read saw the Site's
 	// own completed value, zero meaning it did not (issue #168). A poller
 	// fact, not reading progress: Upsert never touches it.
 	SiteCompletedAt int64
 	// LatestRaisedBy is the Reader whose Sighting last raised LatestChapter,
 	// and nil when the stored value is a Poll's own finding. It is what lets a
 	// Poll that contradicts the value downwards name a Reader instead of
@@ -114,7 +107,7 @@ type LanePass struct {
 	GapMS                           int64
 	Clamped                         bool
 	Refused, Unreachable, NoChapter int
-	Unfetchable, Errors, NotFound   int
+	Unfetchable, Errors             int
 	PausedUntil, RefuseUntil        int64
 }
@@ -123,7 +116,7 @@ type LanePass struct {
 type SiteOutcomes struct {
 	Site                            string
 	Refused, Unreachable, NoChapter int
-	Unfetchable, Errors, NotFound   int
+	Unfetchable, Errors             int
 }
 // LanePause is one persisted Lane pause stamp.
@@ -221,11 +214,10 @@ const (
 )
 // Lifecycle buckets. A bookmark is in exactly one; favorite is orthogonal.
 // Finished is not a bucket: it is a fact about the Series (series.finished_at),
 // never about a Reader's bookmark.
 const (
 	StatusReading  = "reading"
 	StatusArchived = "archived"
 	StatusFinished = "finished"
 )
 //go:embed migrations/*.sql
@@ -237,18 +229,16 @@ var migrations embed.FS
 // order, so the flat Bookmark reads back whole despite the split (ADR-0004).
 const bookmarkColumns = `b.site, b.series_id, s.title, s.series_url, s.cover_address,
 	b.last_chapter, b.last_chapter_num, b.last_chapter_url,
-	b.favorite, s.latest_chapter, s.latest_chapter_num, b.updated_at, b.status, s.kind,
+	b.favorite, s.latest_chapter, s.latest_chapter_num, b.updated_at, b.status, s.kind`
 	s.finished_at > 0`
 // seriesColumns is the series row in scanSeries order, used by the poller's
 // due query. latest_checked_at lives only on series — see MarkLatestChecked
 // for why it stays off every client-visible write.
 const seriesColumns = `s.site, s.series_id, s.title, s.series_url, s.cover, s.cover_address,
-	s.kind, s.latest_chapter, s.latest_chapter_num, s.latest_checked_at, s.latest_raised_by,
+	s.kind, s.latest_chapter, s.latest_chapter_num, s.latest_checked_at, s.latest_raised_by`
 	s.site_completed_at`
 const lanePassColumns = `p.site, p.ran_at, p.skip, p.due, p.checked, p.gap_ms, p.clamped,
-	p.refused, p.unreachable, p.no_chapter, p.unfetchable, p.errors, p.not_found,
+	p.refused, p.unreachable, p.no_chapter, p.unfetchable, p.errors,
 	COALESCE(l.paused_until, 0), COALESCE(l.refuse_until, 0)`
 // Owner is the person running the service: the first Reader, seeded at startup
@@ -618,7 +608,6 @@ func (s *Store) scanBookmark(scan func(...any) error) (Bookmark, error) {
 		&b.Site, &b.SeriesID, &b.Title, &b.SeriesURL, &coverAddress,
 		&b.LastChapter, &b.LastChapterNum, &b.LastChapterURL,
 		&b.Favorite, &b.LatestChapter, &latestChapterNum, &b.UpdatedAt, &b.Status, &b.Kind,
 		&b.Finished,
 	); err != nil {
 		return Bookmark{}, err
 	}
@@ -630,9 +619,9 @@ func (s *Store) scanBookmark(scan func(...any) error) (Bookmark, error) {
 	// bookmark is keyed (reader_id, site, series_id) (issue #22).
 	b.Key = b.Site + ":" + b.SeriesID
 	// An unrecognised bucket (a hand-edited row) would leave the row in no list
-	// at all, so anything outside the two known buckets reads as the default
+	// at all, so anything outside the three known buckets reads as the default
 	// rather than being passed through.
-	if b.Status != StatusReading && b.Status != StatusArchived {
+	if b.Status != StatusReading && b.Status != StatusArchived && b.Status != StatusFinished {
 		b.Status = StatusReading
 	}
 	return b, nil
@@ -651,7 +640,7 @@ func scanSeries(scan func(...any) error) (Series, error) {
 	if err := scan(
 		&sr.Site, &sr.SeriesID, &sr.Title, &sr.SeriesURL, &sr.Cover, &sr.CoverAddress,
 		&sr.Kind, &sr.LatestChapter, &latestChapterNum, &sr.LatestCheckedAt, &latestRaisedBy,
-		&sr.SiteCompletedAt, &sr.Forced, &sr.readerCount,
+		&sr.Forced, &sr.readerCount,
 	); err != nil {
 		return Series{}, err
 	}
@@ -668,7 +657,7 @@ func scanLanePass(scan func(...any) error) (LanePass, error) {
 	var p LanePass
 	if err := scan(
 		&p.Site, &p.RanAt, &p.Skip, &p.Due, &p.Checked, &p.GapMS, &p.Clamped,
-		&p.Refused, &p.Unreachable, &p.NoChapter, &p.Unfetchable, &p.Errors, &p.NotFound,
+		&p.Refused, &p.Unreachable, &p.NoChapter, &p.Unfetchable, &p.Errors,
 		&p.PausedUntil, &p.RefuseUntil,
 	); err != nil {
 		return LanePass{}, err
@@ -1136,10 +1125,10 @@ func (s *Store) RecordLanePass(p LanePass, retainBefore int64) error {
 	if _, err := tx.Exec(`
 		INSERT INTO poll_passes
 			(site, ran_at, skip, due, checked, gap_ms, clamped,
-			 refused, unreachable, no_chapter, unfetchable, errors, not_found)
+			 refused, unreachable, no_chapter, unfetchable, errors)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13)`,
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12)`,
 		p.Site, p.RanAt, p.Skip, p.Due, p.Checked, p.GapMS, p.Clamped,
-		p.Refused, p.Unreachable, p.NoChapter, p.Unfetchable, p.Errors, p.NotFound); err != nil {
+		p.Refused, p.Unreachable, p.NoChapter, p.Unfetchable, p.Errors); err != nil {
 		return fmt.Errorf("insert lane pass %s at %d: %w", p.Site, p.RanAt, err)
 	}
 	if _, err := tx.Exec(`DELETE FROM poll_passes WHERE ran_at < $1`, retainBefore); err != nil {
@@ -1176,7 +1165,7 @@ func (s *Store) LatestLanePasses() ([]LanePass, error) {
 		FROM (
 			SELECT DISTINCT ON (site)
 				site, ran_at, skip, due, checked, gap_ms, clamped,
-				refused, unreachable, no_chapter, unfetchable, errors, not_found
+				refused, unreachable, no_chapter, unfetchable, errors
 			FROM poll_passes
 			ORDER BY site, ran_at DESC
 		) p
@@ -1203,7 +1192,7 @@ func (s *Store) LatestLanePasses() ([]LanePass, error) {
 func (s *Store) LanePassOutcomes(since int64) ([]SiteOutcomes, error) {
 	rows, err := s.db.Query(`
 		SELECT site, SUM(refused), SUM(unreachable), SUM(no_chapter),
-		       SUM(unfetchable), SUM(errors), SUM(not_found)
+		       SUM(unfetchable), SUM(errors)
 		FROM poll_passes
 		WHERE ran_at >= $1
 		GROUP BY site
@@ -1218,7 +1207,7 @@ func (s *Store) LanePassOutcomes(since int64) ([]SiteOutcomes, error) {
 		var outcomes SiteOutcomes
 		if err := rows.Scan(
 			&outcomes.Site, &outcomes.Refused, &outcomes.Unreachable,
-			&outcomes.NoChapter, &outcomes.Unfetchable, &outcomes.Errors, &outcomes.NotFound,
+			&outcomes.NoChapter, &outcomes.Unfetchable, &outcomes.Errors,
 		); err != nil {
 			return nil, fmt.Errorf("scan lane pass outcomes: %w", err)
 		}
@@ -1227,101 +1216,6 @@ func (s *Store) LanePassOutcomes(since int64) ([]SiteOutcomes, error) {
 	return out, rows.Err()
 }
 // RefusingSince reports, per Site, when that Site's current unbroken run of
 // refusing passes began: a pass refuses when the Lane gate returned early
 // (skip = 'refusing') or the pass loop counted refusals (refused > 0), so a
 // Site parked in refusal backoff keeps its run unbroken. A Site whose
 // latest pass did not refuse is absent. The run is bounded by the pass
 // log's retention — a run older than the log answers with the oldest row
 // present — and nothing after now counts: the cutoff is the caller's clock.
 func (s *Store) RefusingSince(now int64) (map[string]int64, error) {
 	rows, err := s.db.Query(`
 		SELECT site, MIN(ran_at)
 		FROM poll_passes p
 		WHERE ran_at <= $1
 		  AND (refused > 0 OR skip = 'refusing')
 		  AND ran_at > COALESCE((
 		      SELECT MAX(q.ran_at) FROM poll_passes q
 		      WHERE q.site = p.site AND q.ran_at <= $1
 		        AND NOT (q.refused > 0 OR q.skip = 'refusing')
 		  ), 0)
 		GROUP BY site`, now)
 	if err != nil {
 		return nil, fmt.Errorf("query refusing since: %w", err)
 	}
 	defer rows.Close()
 	out := map[string]int64{}
 	for rows.Next() {
 		var site string
 		var since int64
 		if err := rows.Scan(&site, &since); err != nil {
 			return nil, fmt.Errorf("scan refusing since: %w", err)
 		}
 		out[site] = since
 	}
 	return out, rows.Err()
 }
 // SidecarOK reports, per Site in sites, the unix ms of that Site's most
 // recent pass that actually reached the sidecar: the pass ran its loop
 // (skip = '') and no Series read lost Chrome (unreachable = 0) — a
 // challenge answer still reached the sidecar, a lost sidecar did not. A
 // Site with no such pass is absent: an asleep Lane never reached it, so it
 // is absent too and cannot age into a sidecar-down alarm by itself.
 func (s *Store) SidecarOK(sites []string) (map[string]int64, error) {
 	rows, err := s.db.Query(`
 		SELECT DISTINCT ON (site) site, ran_at
 		FROM poll_passes
 		WHERE site = ANY($1) AND skip = '' AND unreachable = 0
 		ORDER BY site, ran_at DESC`, sites)
 	if err != nil {
 		return nil, fmt.Errorf("query sidecar ok: %w", err)
 	}
 	defer rows.Close()
 	out := map[string]int64{}
 	for rows.Next() {
 		var site string
 		var ranAt int64
 		if err := rows.Scan(&site, &ranAt); err != nil {
 			return nil, fmt.Errorf("scan sidecar ok: %w", err)
 		}
 		out[site] = ranAt
 	}
 	return out, rows.Err()
 }
 // NoChapterShare reports, per Site, the share of that Site's Series holding
 // a no-chapter failure row older than cutoff: old rows over the Site's
 // whole Series count, so a four-Series Site and a 200-Series Site are
 // judged on the same scale. A Site with no Series has no share and is
 // absent.
 func (s *Store) NoChapterShare(cutoff int64) (map[string]float64, error) {
 	rows, err := s.db.Query(`
 		SELECT s.site,
 		       (COUNT(*) FILTER (WHERE f.outcome = 'no_chapter' AND f.failing_since < $1))::float8
 		         / (COUNT(*)::float8)
 		FROM series s
 		LEFT JOIN poll_failures f ON f.site = s.site AND f.series_id = s.series_id
 		GROUP BY s.site
 		ORDER BY s.site`, cutoff)
 	if err != nil {
 		return nil, fmt.Errorf("query no-chapter share: %w", err)
 	}
 	defer rows.Close()
 	out := map[string]float64{}
 	for rows.Next() {
 		var site string
 		var share float64
 		if err := rows.Scan(&site, &share); err != nil {
 			return nil, fmt.Errorf("scan no-chapter share: %w", err)
 		}
 		out[site] = share
 	}
 	return out, rows.Err()
 }
 // SetLaneRefusal persists a Site's refusal backoff stamp without touching its
 // pause. until is supplied by the caller's clock.
 func (s *Store) SetLaneRefusal(site string, until int64) error {
@@ -1398,72 +1292,6 @@ func (s *Store) LaneGates(site string) (pausedUntil, refuseUntil int64, err erro
 	return pausedUntil, refuseUntil, nil
 }
 // RecordSeriesFailure upserts one Series' failure row: the outcome word is
 // updated when it changes, failing_since is never overwritten, and an
 // unchanged word writes nothing. One statement, so the identical-word no-op
 // and the keep-the-stamp rule are the same guarantee: the SET arm fires only
 // when the word differs, and failing_since is simply absent from it
 // (ADR-0016).
 func (s *Store) RecordSeriesFailure(site, seriesID, outcome string, now int64) error {
 	if _, err := s.db.Exec(`
 		INSERT INTO poll_failures (site, series_id, outcome, failing_since) VALUES ($1, $2, $3, $4)
 		ON CONFLICT (site, series_id) DO UPDATE SET outcome = EXCLUDED.outcome
 		WHERE poll_failures.outcome <> EXCLUDED.outcome`, site, seriesID, outcome, now); err != nil {
 		return fmt.Errorf("record series failure %s:%s: %w", site, seriesID, err)
 	}
 	return nil
 }
 // ClearSeriesFailure deletes one Series' failure row. A row that is not there
 // is not an error.
 func (s *Store) ClearSeriesFailure(site, seriesID string) error {
 	if _, err := s.db.Exec(
 		`DELETE FROM poll_failures WHERE site = $1 AND series_id = $2`, site, seriesID); err != nil {
 		return fmt.Errorf("clear series failure %s:%s: %w", site, seriesID, err)
 	}
 	return nil
 }
 // NoticeSent reports whether the owner has already been told about this
 // episode (issue #171). The row's presence is the whole state, so a missing
 // row reads false without error.
 func (s *Store) NoticeSent(condition, site string) (bool, error) {
 	var at int64
 	err := s.db.QueryRow(
 		`SELECT notified_at FROM owner_notices WHERE condition = $1 AND site = $2`,
 		condition, site).Scan(&at)
 	if errors.Is(err, sql.ErrNoRows) {
 		return false, nil
 	}
 	if err != nil {
 		return false, fmt.Errorf("notice sent %s/%s: %w", condition, site, err)
 	}
 	return true, nil
 }
 // MarkNoticeSent records that the owner was told. Called only after a
 // successful send. Re-marking the same episode just moves the stamp: the row
 // is a lock against a second message, not a log.
 func (s *Store) MarkNoticeSent(condition, site string, at int64) error {
 	if _, err := s.db.Exec(`
 		INSERT INTO owner_notices (condition, site, notified_at) VALUES ($1, $2, $3)
 		ON CONFLICT (condition, site) DO UPDATE SET notified_at = EXCLUDED.notified_at`,
 		condition, site, at); err != nil {
 		return fmt.Errorf("mark notice sent %s/%s: %w", condition, site, err)
 	}
 	return nil
 }
 // ClearNotice forgets an episode, so the condition's next occurrence sends
 // again. A row that is not there is not an error.
 func (s *Store) ClearNotice(condition, site string) error {
 	if _, err := s.db.Exec(
 		`DELETE FROM owner_notices WHERE condition = $1 AND site = $2`, condition, site); err != nil {
 		return fmt.Errorf("clear notice %s/%s: %w", condition, site, err)
 	}
 	return nil
 }
 // DueForLatestCheck returns one Site's series whose server-side
 // latest-chapter check has aged past cutoffMs, ordered by how many bookmarks
 // reference them (descending) then least-recently-checked first. One Site per
@@ -1474,12 +1302,10 @@ func (s *Store) ClearNotice(condition, site string) error {
 //
 // A forced Series (force_poll_at newer than latest_checked_at, issue #146)
 // overrides exactly three gates: the rest cutoff, the Sighting-deferral
-// clause and a finished Series. It never overrides an empty series_url or the
+// clause and the finished-only bucket. It never overrides an empty
-// Bookmarks join — nothing to fetch, and no consumer for the result — so
+// series_url or the Bookmarks join — nothing to fetch, and no consumer for
-// those stay unconditional, and it never clears the finish: nothing here
+// the result — so those stay unconditional. Forced rows sort to the front of
-// writes finished_at, and pending force clears itself when the pass stamps
+// the queue; the reader-count-then-age ordering among the rest is ADR-0003.
 // the check timestamp. Forced rows sort to the front of the queue; the
 // reader-count-then-age ordering among the rest is ADR-0003.
 //
 // The reader_count ordering is the point of the split (ADR-0003): a series
 // shared by several readers is fetched once per due cycle, and the popular
@@ -1487,15 +1313,14 @@ func (s *Store) ClearNotice(condition, site string) error {
 // reader count, oldest-first keeps the poll fair when the backlog outgrows
 // throughput: the most neglected series is always next, so a large collection
 // refreshes uniformly slower rather than leaving a tail that never refreshes
-// at all. The userscript sorts its own queue the same way.
+// at all. The userscript sorts its own queue the same way (L453).
 //
 // Series with no series_url are skipped — there is nothing to fetch, which is
-// the same filter the userscript applies before refreshing. A finished Series is
+// the same filter the userscript applies at L452. Series whose only bookmarks
-// skipped unless forced: nothing more is coming, so fetching it only burns
+// are finished are skipped too: nothing more is coming, so fetching them only
-// requests (issue #157). Archived bookmarks still count — knowing what a
+// burns requests. Archived bookmarks still count — knowing what a shelved
-// shelved series is up to is the whole reason for archiving instead of
+// series is up to is the whole reason for archiving instead of deleting.
-// deleting. A series with no bookmarks at all never appears: the join
+// A series with no bookmarks at all never appears: the join excludes it.
 // excludes it.
 //
 // ceilingMs is the Sighting deferral ceiling (issue #103): a Series whose last
 // real Poll is older than it appears however recently it was sighted. That is
@@ -1504,10 +1329,10 @@ func (s *Store) ClearNotice(condition, site string) error {
 // decided here, from two facts the query already computes, so a Lane gains no
 // query per round: a Sighting younger than cutoffMs holds the Series back, but
 // only while COUNT(*) is 1. A Series a second Reader bookmarks is Polled on
-// the schedule, so a wrong value the guild can see is corrected by a check
+// schedule, so a wrong value the whole guild can see is corrected by a check
-// that was never postponed; on a solitary Series the only person a wrong
+// that was never postponed; on a solitary Series the only person a wrong value
-// value reaches is the Reader who reported it. Whether the reporting Reader
+// reaches is the Reader who reported it. Whether the reporting Reader is
-// is allowed to defer at all was settled when the Sighting was recorded — see
+// allowed to defer at all was settled when the Sighting was recorded — see
 // RecordSighting.
 func (s *Store) DueForLatestCheck(site string, cutoffMs, ceilingMs int64) ([]Series, error) {
 	rows, err := s.db.Query(`SELECT `+seriesColumns+`,
@@ -1519,11 +1344,12 @@ func (s *Store) DueForLatestCheck(site string, cutoffMs, ceilingMs int64) ([]Ser
 		  AND s.series_url <> ''
 		  AND (s.latest_checked_at <= $2::bigint
 		       OR s.force_poll_at > s.latest_checked_at)
 		  AND (s.finished_at = 0 OR s.force_poll_at > s.latest_checked_at)
 		GROUP BY s.site, s.series_id, s.title, s.series_url, s.cover,
 		         s.kind, s.latest_chapter, s.latest_chapter_num, s.latest_checked_at,
-		         s.site_completed_at, s.force_poll_at, s.finished_at
+		         s.force_poll_at
-		HAVING (COUNT(*) > 1
+		HAVING (COUNT(*) FILTER (WHERE b.status <> 'finished') > 0
 		        OR s.force_poll_at > s.latest_checked_at)
 		   AND (COUNT(*) > 1
 		        OR s.latest_sighted_at <= $2::bigint
 		        OR s.latest_checked_at <= $3::bigint
 		        OR s.force_poll_at > s.latest_checked_at)
@@ -1545,18 +1371,14 @@ func (s *Store) DueForLatestCheck(site string, cutoffMs, ceilingMs int64) ([]Ser
 	return out, rows.Err()
 }
-// EligibleSeriesCount returns how many of a Site's Series are not finished —
+// EligibleSeriesCount returns how many of a Site's Series still have at least
-// the flag, never a Reader vote. It is the denominator of the Lane's pace
+// one bookmark outside the finished bucket. It is the denominator of the
-// (issue #100): the effective gap is the smaller of the registry gap and one
+// Lane's pace (issue #100): the effective gap is the smaller of the registry
-// hour divided by this count, so Series that will never be Polled do not make
+// gap and one hour divided by this count, so Series that will never be Polled
-// the Lane faster than it needs to be, and counting every eligible Series
+// do not make the Lane faster than it needs to be, and counting every eligible
-// rather than only those currently due keeps the pace steady — the single
+// Series rather than only those currently due keeps the pace steady — the
-// worst moment to be fastest is startup, when everything is due at once.
+// single worst moment to be fastest is startup, when everything is due at
-//
+// once.
 // The deliberate asymmetry with DueForLatestCheck's WHERE: a forced Series
 // is due but never admitted here, because a forced pass must not speed up
 // every other fetch on the Site — one impassioned press is not a reason to
 // hammer the Site (issue #157).
 func (s *Store) EligibleSeriesCount(site string) (int, error) {
 	var n int
 	err := s.db.QueryRow(`SELECT COUNT(*) FROM (
@@ -1564,8 +1386,8 @@ func (s *Store) EligibleSeriesCount(site string) (int, error) {
 		FROM series s
 		JOIN bookmarks b ON b.site = s.site AND b.series_id = s.series_id
 		WHERE s.site = $1
 		  AND s.finished_at = 0
 		GROUP BY s.site, s.series_id
 		HAVING COUNT(*) FILTER (WHERE b.status <> 'finished') > 0
 	) e`, site).Scan(&n)
 	if err != nil {
 		return 0, fmt.Errorf("count eligible series %s: %w", site, err)
@@ -1611,21 +1433,6 @@ func (s *Store) ForceSeriesPoll(site, seriesID string, at int64) error {
 	return nil
 }
 // SetSeriesFinished stamps or clears the owner's finish. at is unix ms to
 // finish, zero to un-finish. A finished Series drops out of the Lane's reads
 // (issue #157), and nothing else writes this column: it is the only writer
 // outside migration 0016, so a machine write can never retire a Series
 // silently. Touching a missing series is not an error: the row may have been
 // orphaned, and the caller's read decides what exists.
 func (s *Store) SetSeriesFinished(site, seriesID string, at int64) error {
 	if _, err := s.db.Exec(
 		`UPDATE series SET finished_at = $1 WHERE site = $2 AND series_id = $3`,
 		at, site, seriesID); err != nil {
 		return fmt.Errorf("set series finished %s:%s: %w", site, seriesID, err)
 	}
 	return nil
 }
 // LatestCheckedAt reads the column MarkLatestChecked writes. It exists for
 // tests outside this package (the poller's own tests assert on rest
 // bookkeeping) — see MarkLatestChecked for why the field stays off the
@@ -1657,22 +1464,6 @@ func (s *Store) SetLatestChapter(site, seriesID, label string, num float64) erro
 	return nil
 }
 // SetSiteCompletedAt stores when the last successful read saw the Site's
 // completed value, zero meaning it did not. Series-level, like the Latest
 // Chapter: it is a fact about the work, not about one Reader's bookmark, and
 // the bookmark's updated_at is never touched — this is not reading progress
 // and must not reorder any Reader's list, the same rule SetLatestChapter's
 // comment states. Touching a missing series is not an error: the row may
 // have been orphaned, and the caller's read decides what exists.
 func (s *Store) SetSiteCompletedAt(site, seriesID string, at int64) error {
 	if _, err := s.db.Exec(
 		`UPDATE series SET site_completed_at = $1 WHERE site = $2 AND series_id = $3`,
 		at, site, seriesID); err != nil {
 		return fmt.Errorf("set site completed %s:%s: %w", site, seriesID, err)
 	}
 	return nil
 }
 // SetSeriesURL stores the owner's repair for a Series' source address
 // (issue #151): the one write that lifts the write-once rule documented on
 // Series.SeriesURL. It is a store, not a verification — the caller has
@@ -7,7 +7,6 @@ import (
 	"encoding/hex"
 	"errors"
 	"io/fs"
 	"fmt"
 	"os"
 	"path/filepath"
 	"strconv"
@@ -280,27 +279,6 @@ func seedForCheck(t *testing.T, s *Store, key, seriesURL string, checkedAt int64
 	}
 }
 // seedFinished inserts a bookmark (and with it its series) and stamps the
 // series finished — the series-level fact the due gate reads (issue #157).
 func seedFinished(t *testing.T, s *Store, key, seriesURL string) {
 	t.Helper()
 	site, seriesID, ok := strings.Cut(key, ":")
 	if !ok {
 		t.Fatalf("key %q: no ':' separator", key)
 	}
 	if _, err := s.Upsert(s.OwnerID(), Bookmark{
 		Key: key, Site: site, SeriesID: seriesID, SeriesURL: seriesURL,
 		UpdatedAt: 1000,
 	}); err != nil {
 		t.Fatalf("seed %q: %v", key, err)
 	}
 	if _, err := s.db.Exec(
 		`UPDATE series SET finished_at = 1000 WHERE site = $1 AND series_id = $2`,
 		site, seriesID); err != nil {
 		t.Fatalf("seed finish %q: %v", key, err)
 	}
 }
 // noCeiling is a Sighting deferral ceiling no Series can reach, for the tests
 // that predate the ceiling and are about rest, ordering or buckets instead.
 const noCeiling = int64(-1)
@@ -508,15 +486,24 @@ func TestUpsertStatusChangeKeepsUpdatedAt(t *testing.T) {
 		t.Fatalf("UpdatedAt = %d, want it frozen at %d", stored.UpdatedAt, first.UpdatedAt)
 	}
 }
 // Archiving is the reason to keep polling — the point is to come back to a
-// series that has moved on. A finished series has nothing left to publish,
+// series that has moved on. A finished series has nothing left to publish.
 // whichever Reader marked it (issue #157).
 func TestDueForLatestCheckSkipsFinishedKeepsArchived(t *testing.T) {
 	store := newTestStore(t)
-	for _, key := range []string{"asura:reading", "asura:archived"} {
+	for _, tc := range []struct{ key, status string }{
-		seedForCheck(t, store, key, "https://asurascans.com/comics/"+key, 0)
+		{"asura:reading", StatusReading},
 		{"asura:archived", StatusArchived},
 		{"asura:finished", StatusFinished},
 	} {
 		if _, err := store.Upsert(store.OwnerID(), Bookmark{
 			Key: tc.key, Site: "asura", SeriesID: strings.TrimPrefix(tc.key, "asura:"),
 			SeriesURL: "https://asurascans.com/comics/" + tc.key,
 			Status:    tc.status, UpdatedAt: time.Now().UnixMilli(),
 		}); err != nil {
 			t.Fatalf("seed %s: %v", tc.key, err)
 		}
 	}
 	seedFinished(t, store, "asura:finished", "https://asurascans.com/comics/asura:finished")
 	due, err := store.DueForLatestCheck("asura", time.Now().UnixMilli(), noCeiling)
 	if err != nil {
@@ -535,26 +522,27 @@ func TestDueForLatestCheckSkipsFinishedKeepsArchived(t *testing.T) {
 }
 // The gap's denominator counts every Series the Lane will ever Poll: a
-// finished Series must not make the Lane faster than it needs to be, another
+// finished Series must not make the Lane faster than it needs to be, and
-// Site's Series must not leak into this Site's count, and a forced Series is
+// another Site's Series must not leak into this Site's count.
 // not admitted either — it is due once, not a reason to tighten the pace for
 // every other fetch on the Site (issue #157).
 func TestEligibleSeriesCount(t *testing.T) {
 	store := newTestStore(t)
 	seedForCheck(t, store, "asura:reading", "https://asurascans.com/comics/reading", 0)
 	seedForCheck(t, store, "asura:archived", "https://asurascans.com/comics/archived", 0)
-	seedFinished(t, store, "asura:finished", "https://asurascans.com/comics/asura:finished")
+	if _, err := store.Upsert(store.OwnerID(), Bookmark{
-	seedForCheck(t, store, "demonic:z", "https://demonicscans.org/manga/z", 0)
+		Key: "asura:finished", Site: "asura", SeriesID: "finished",
-	if err := store.ForceSeriesPoll("asura", "archived", 5000); err != nil {
+		SeriesURL: "https://asurascans.com/comics/finished",
-		t.Fatalf("ForceSeriesPoll: %v", err)
+		Status:    StatusFinished, UpdatedAt: 1000,
 	}); err != nil {
 		t.Fatalf("seed finished: %v", err)
 	}
 	seedForCheck(t, store, "demonic:z", "https://demonicscans.org/manga/z", 0)
 	n, err := store.EligibleSeriesCount("asura")
 	if err != nil {
 		t.Fatalf("EligibleSeriesCount: %v", err)
 	}
 	if n != 2 {
-		t.Fatalf("eligible = %d, want 2 (finished and forced excluded, demonic excluded)", n)
+		t.Fatalf("eligible = %d, want 2 (finished excluded, demonic excluded)", n)
 	}
 	n, err = store.EligibleSeriesCount("demonic")
 	if err != nil {
@@ -767,133 +755,6 @@ func TestMigration0008DropsLegacyCoverRows(t *testing.T) {
 	}
 }
 // 0016's three statements are order-dependent: the finished_at seed must see
 // the pre-flip 'finished' buckets, and the flip must come after it. A seed
 // that ran after the flip would read bookmarks that no longer say
 // 'finished', declare nothing finished, and silently resume polling series
 // somebody marked done. This seeds a pre-0016 database the way every
 // deployment looked — finished a bookmark bucket, no finished_at column —
 // runs the migration, and asserts on what it preserved.
 func TestMigration0016SeedsFinishedAtBeforeFlippingBucket(t *testing.T) {
 	url := pgtest.URL(t)
 	db, err := sql.Open("pgx", url)
 	if err != nil {
 		t.Fatalf("open: %v", err)
 	}
 	defer db.Close()
 	if err := migrate(db, 15); err != nil {
 		t.Fatalf("migrate to 0015: %v", err)
 	}
 	if err := seedOwner(db, testOwner); err != nil {
 		t.Fatalf("seed owner: %v", err)
 	}
 	// A second reader, so "mixed" can carry two bookmarks on one series.
 	if _, err := db.Exec(
 		`INSERT INTO readers (discord_id, token_sha256) VALUES ('second', '\x01'::bytea)`); err != nil {
 		t.Fatalf("seed second reader: %v", err)
 	}
 	owner := func() int64 {
 		t.Helper()
 		var id int64
 		if err := db.QueryRow(
 			`SELECT id FROM readers WHERE discord_id = $1`, testOwner.DiscordID).Scan(&id); err != nil {
 			t.Fatalf("owner id: %v", err)
 		}
 		return id
 	}()
 	seedBookmark := func(readerID int64, site, seriesID, status string) {
 		t.Helper()
 		// The bookmark FK demands the series row; Upsert would create it on
 		// the fly, raw SQL has to spell it out.
 		if _, err := db.Exec(
 			`INSERT INTO series (site, series_id) VALUES ($1, $2) ON CONFLICT DO NOTHING`,
 			site, seriesID); err != nil {
 			t.Fatalf("seed series %s:%s: %v", site, seriesID, err)
 		}
 		if _, err := db.Exec(
 			`INSERT INTO bookmarks (reader_id, site, series_id, status, updated_at)
 			 VALUES ($1, $2, $3, $4, 1000)`, readerID, site, seriesID, status); err != nil {
 			t.Fatalf("seed %s:%s/%s: %v", site, seriesID, status, err)
 		}
 	}
 	// done: the one-bookmark series every finished series looked like.
 	seedBookmark(owner, "asura", "done", "finished")
 	// shared: every reader finished — the multi-reader equivalent.
 	seedBookmark(owner, "asura", "shared", "finished")
 	// mixed: a second reader still reading keeps the series alive.
 	seedBookmark(owner, "asura", "mixed", "finished")
 	seedBookmark(owner+1, "asura", "mixed", "archived")
 	// live: nobody finished it.
 	seedBookmark(owner, "asura", "live", "reading")
 	// orphan: no bookmarks at all, nothing to decide from.
 	if _, err := db.Exec(
 		`INSERT INTO series (site, series_id) VALUES ('asura', 'orphan')`); err != nil {
 		t.Fatalf("seed orphan: %v", err)
 	}
 	if err := migrate(db, 0); err != nil {
 		t.Fatalf("migrate 0016: %v", err)
 	}
 	finishedAt := func(site, seriesID string) int64 {
 		t.Helper()
 		var at int64
 		if err := db.QueryRow(
 			`SELECT finished_at FROM series WHERE site = $1 AND series_id = $2`,
 			site, seriesID).Scan(&at); err != nil {
 			t.Fatalf("finished_at %s:%s: %v", site, seriesID, err)
 		}
 		return at
 	}
 	status := func(readerID int64, site, seriesID string) string {
 		t.Helper()
 		var s string
 		if err := db.QueryRow(
 			`SELECT status FROM bookmarks WHERE reader_id = $1
 			   AND site = $2 AND series_id = $3`, readerID, site, seriesID).Scan(&s); err != nil {
 			t.Fatalf("status %s:%s: %v", site, seriesID, err)
 		}
 		return s
 	}
 	// The seed ran before the flip: had the flip gone first, done's bookmarks
 	// would read archived and nothing would be stamped. The stamp is a real
 	// timestamp, not a sentinel.
 	before := time.Now().Add(-time.Minute).UnixMilli()
 	after := time.Now().Add(time.Minute).UnixMilli()
 	for _, sr := range []struct{ site, seriesID string }{
 		{"asura", "done"}, {"asura", "shared"},
 	} {
 		if at := finishedAt(sr.site, sr.seriesID); at < before || at > after {
 			t.Fatalf("%s:%s finished_at = %d, want now-ish", sr.site, sr.seriesID, at)
 		}
 		// The flip followed the seed: every finished bookmark is archived.
 		if s := status(owner, sr.site, sr.seriesID); s != StatusArchived {
 			t.Fatalf("%s:%s status = %q, want archived after the flip", sr.site, sr.seriesID, s)
 		}
 	}
 	// The seed ignores a series any bookmark keeps alive.
 	if at := finishedAt("asura", "mixed"); at != 0 {
 		t.Fatalf("mixed finished_at = %d, want 0", at)
 	}
 	// The flip is a bucket rewrite, not a series-wide one: the finished
 	// bookmark becomes archived and the sibling rows keep their buckets.
 	if s := status(owner, "asura", "mixed"); s != StatusArchived {
 		t.Fatalf("mixed finished bookmark = %q, want archived", s)
 	}
 	if s := status(owner+1, "asura", "mixed"); s != StatusArchived {
 		t.Fatalf("mixed archived bookmark = %q, want untouched archived", s)
 	}
 	if s := status(owner, "asura", "live"); s != StatusReading {
 		t.Fatalf("live status = %q, want untouched reading", s)
 	}
 	if at := finishedAt("asura", "orphan"); at != 0 {
 		t.Fatalf("orphan finished_at = %d, want 0", at)
 	}
 }
 // readSeries reads the series row directly, for asserting on what Upsert
 // actually stored rather than what the joined Bookmark reports.
 func readSeries(t *testing.T, s *Store, site, seriesID string) Series {
@@ -935,37 +796,6 @@ func TestUpsertCreatesSeriesFromClient(t *testing.T) {
 	}
 }
 // The wire's finished flag is derived, never stored: the Upsert's explicit
 // column list does not name finished_at — the same omission that protects
 // cover — so a client echoing a cached flag, true or false, cannot change the
 // Series' retired state (issues #157, #160).
 func TestUpsertCannotWriteSeriesFinished(t *testing.T) {
 	store := newTestStore(t)
 	seedFinished(t, store, "asura:done", "https://asurascans.com/comics/asura:done")
 	for _, sent := range []bool{true, false} {
 		stored, err := store.Upsert(store.OwnerID(), Bookmark{
 			Key: "asura:done", Site: "asura", SeriesID: "done",
 			Finished: sent, UpdatedAt: 2000,
 		})
 		if err != nil {
 			t.Fatalf("Upsert(Finished: %v): %v", sent, err)
 		}
 		if !stored.Finished {
 			t.Fatalf("stored.Finished = false after echoing %v, want true", sent)
 		}
 	}
 	var finishedAt int64
 	if err := store.db.QueryRow(
 		`SELECT finished_at FROM series WHERE site = $1 AND series_id = $2`,
 		"asura", "done").Scan(&finishedAt); err != nil {
 		t.Fatalf("read finished_at: %v", err)
 	}
 	if finishedAt != 1000 {
 		t.Fatalf("series.finished_at = %v, want the seeded 1000 untouched", finishedAt)
 	}
 }
 // The hook is what starts creation-time acquisition, so it must fire exactly
 // once per Series — on the PUT that created it, and on no later one, whichever
 // Reader sends it.
@@ -1979,12 +1809,19 @@ func TestDueForLatestCheckForcedOverridesSightingDeferral(t *testing.T) {
 	}
 }
-// The finished flag excludes a series; a forced request overrides it — the
+// The finished-only bucket excludes a series whose only bookmarks are
-// owner asked, so the Lane looks.
+// finished; a forced request overrides it — the owner asked, so the Lane
-func TestDueForLatestCheckForcedOverridesFinishedFlag(t *testing.T) {
+// looks.
 func TestDueForLatestCheckForcedOverridesFinishedBucket(t *testing.T) {
 	s := newTestStore(t)
 	seedForCheck(t, s, "asura:reading", "https://asurascans.com/comics/reading", 0)
-	seedFinished(t, s, "asura:finished", "https://asurascans.com/comics/asura:finished")
+	if _, err := s.Upsert(s.OwnerID(), Bookmark{
 		Key: "asura:finished", Site: "asura", SeriesID: "finished",
 		SeriesURL: "https://asurascans.com/comics/finished",
 		Status:    StatusFinished, UpdatedAt: 1000,
 	}); err != nil {
 		t.Fatalf("seed finished: %v", err)
 	}
 	due, err := s.DueForLatestCheck("asura", 1000, noCeiling)
 	if err != nil {
@@ -2612,288 +2449,3 @@ func TestRemoveSeriesMissingKeyIsCleanNoOp(t *testing.T) {
 		t.Fatalf("RemoveSeries on a missing key = %v, want nil", err)
 	}
 }
 // The failure row's existence is the failure state (ADR-0016):
 // RecordSeriesFailure upserts the outcome word, keeps the original
 // failing_since through a word change, and an unchanged word writes nothing
 // at all — a broken Series costs the same as a healthy one every hour.
 func TestRecordSeriesFailureUpsertKeepsFailingSince(t *testing.T) {
 	s := newTestStore(t)
 	seedForCheck(t, s, "asura:solo", "https://asurascans.com/comics/solo", 0)
 	if err := s.RecordSeriesFailure("asura", "solo", "not_found", 1000); err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	word, since, found := failureRow(t, s, "asura", "solo")
 	if !found || word != "not_found" || since != 1000 {
 		t.Fatalf("row after create = (%q, %d, %v), want (not_found, 1000, true)", word, since, found)
 	}
 	// A changed word updates the outcome and never touches failing_since.
 	if err := s.RecordSeriesFailure("asura", "solo", "errors", 2000); err != nil {
 		t.Fatalf("record changed word: %v", err)
 	}
 	word, since, found = failureRow(t, s, "asura", "solo")
 	if !found || word != "errors" || since != 1000 {
 		t.Fatalf("row after word change = (%q, %d, %v), want (errors, 1000, true)", word, since, found)
 	}
 	// An identical word writes nothing: the stamp survives a later now.
 	if err := s.RecordSeriesFailure("asura", "solo", "errors", 3000); err != nil {
 		t.Fatalf("record identical word: %v", err)
 	}
 	word, since, found = failureRow(t, s, "asura", "solo")
 	if !found || word != "errors" || since != 1000 {
 		t.Fatalf("row after identical word = (%q, %d, %v), want the earlier (errors, 1000, true)", word, since, found)
 	}
 }
 // ClearSeriesFailure deletes the row, and a row that is not there is not an
 // error — the poller clears on every successful read, so most clears find
 // nothing.
 func TestClearSeriesFailure(t *testing.T) {
 	s := newTestStore(t)
 	seedForCheck(t, s, "asura:solo", "https://asurascans.com/comics/solo", 0)
 	if err := s.ClearSeriesFailure("asura", "solo"); err != nil {
 		t.Fatalf("clear a missing row: %v, want nil", err)
 	}
 	if err := s.RecordSeriesFailure("asura", "solo", "not_found", 1000); err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	if err := s.ClearSeriesFailure("asura", "solo"); err != nil {
 		t.Fatalf("clear: %v", err)
 	}
 	if _, _, found := failureRow(t, s, "asura", "solo"); found {
 		t.Fatal("row after clear: still present")
 	}
 }
 // Deleting a Series takes its failure row with it (the composite FK's
 // cascade), so orphan removal stays a single statement.
 func TestRemoveSeriesCascadesToFailureRow(t *testing.T) {
 	s := newTestStore(t)
 	seedForCheck(t, s, "asura:solo", "https://asurascans.com/comics/solo", 0)
 	if err := s.RecordSeriesFailure("asura", "solo", "not_found", 1000); err != nil {
 		t.Fatalf("record: %v", err)
 	}
 	if err := s.Delete(s.OwnerID(), "asura:solo"); err != nil {
 		t.Fatalf("delete bookmark: %v", err)
 	}
 	if err := s.RemoveSeries("asura", "solo"); err != nil {
 		t.Fatalf("RemoveSeries: %v", err)
 	}
 	if _, _, found := failureRow(t, s, "asura", "solo"); found {
 		t.Fatal("failure row after series delete: still present (no cascade)")
 	}
 }
 // failureRow reads one Series' failure row as stored.
 func failureRow(t *testing.T, s *Store, site, seriesID string) (word string, since int64, found bool) {
 	t.Helper()
 	err := s.db.QueryRow(
 		`SELECT outcome, failing_since FROM poll_failures WHERE site = $1 AND series_id = $2`,
 		site, seriesID).Scan(&word, &since)
 	if errors.Is(err, sql.ErrNoRows) {
 		return "", 0, false
 	}
 	if err != nil {
 		t.Fatalf("read failure row %s:%s: %v", site, seriesID, err)
 	}
 	return word, since, true
 }
 // Owner notices are one row per episode: the row's presence is the whole
 // state. MarkNoticeSent stamps it, NoticeSent reads it, and ClearNotice
 // forgets it — including a row that was never there, which is not an error.
 func TestOwnerNoticeRows(t *testing.T) {
 	s := newTestStore(t)
 	if sent, err := s.NoticeSent("stall", "comix"); err != nil || sent {
 		t.Fatalf("NoticeSent on a fresh table = %v, %v; want false, nil", sent, err)
 	}
 	if err := s.MarkNoticeSent("stall", "comix", 4242); err != nil {
 		t.Fatalf("MarkNoticeSent: %v", err)
 	}
 	if sent, err := s.NoticeSent("stall", "comix"); err != nil || !sent {
 		t.Fatalf("NoticeSent after mark = %v, %v; want true, nil", sent, err)
 	}
 	// Re-marking the same episode just moves the stamp: the row is a lock,
 	// not a log. A different site is its own episode — the key is
 	// (condition, site).
 	if err := s.MarkNoticeSent("stall", "comix", 4343); err != nil {
 		t.Fatalf("re-mark: %v", err)
 	}
 	if sent, err := s.NoticeSent("stall", "kagane"); err != nil || sent {
 		t.Fatalf("NoticeSent on another site = %v, %v; want false, nil", sent, err)
 	}
 	if err := s.ClearNotice("stall", "comix"); err != nil {
 		t.Fatalf("ClearNotice: %v", err)
 	}
 	if sent, err := s.NoticeSent("stall", "comix"); err != nil || sent {
 		t.Fatalf("NoticeSent after clear = %v, %v; want false, nil", sent, err)
 	}
 	if err := s.ClearNotice("stall", "comix"); err != nil {
 		t.Fatalf("ClearNotice on a missing row: %v", err)
 	}
 }
 // RefusingSince reads one Site's current unbroken run of refusing passes
 // (issue #172). A refusing pass is one the Lane gate returned early from
 // (skip 'refusing') or one whose loop counted refusals (refused > 0) — the
 // two shapes a persistently-challenged Site alternates between, so the run
 // must not break when the gate row follows the refusal row. A Site whose
 // latest pass did not refuse is absent, nothing after the caller's clock
 // counts, and a run older than the log answers with the oldest row present.
 func TestRefusingSince(t *testing.T) {
 	s := newTestStore(t)
 	seed := func(site string, ranAt int64, skip string, refused int) {
 		t.Helper()
 		if err := s.RecordLanePass(LanePass{Site: site, RanAt: ranAt, Skip: skip, Refused: refused}, -1); err != nil {
 			t.Fatalf("RecordLanePass(%s/%d): %v", site, ranAt, err)
 		}
 	}
 	// asura: a refusing run broken by a healthy pass, then resumed; the
 	// current run began at the pass after the break.
 	seed("asura", 100, "", 2)
 	seed("asura", 200, "", 0)
 	seed("asura", 300, "refusing", 0)
 	seed("asura", 400, "", 2)
 	// demonic: the latest pass is healthy — no run, absent.
 	seed("demonic", 100, "", 2)
 	seed("demonic", 200, "", 0)
 	// novelfull: a healthy pass after now must not break the run — the run
 	// is judged as of the caller's clock.
 	seed("novelfull", 100, "", 2)
 	seed("novelfull", 600, "", 0)
 	// comix: an unbroken run reaches back to the oldest row present.
 	seed("comix", 100, "", 2)
 	seed("comix", 200, "refusing", 0)
 	got, err := s.RefusingSince(450)
 	if err != nil {
 		t.Fatalf("RefusingSince: %v", err)
 	}
 	want := map[string]int64{"asura": 300, "novelfull": 100, "comix": 100}
 	if len(got) != len(want) {
 		t.Fatalf("RefusingSince = %v, want %v", got, want)
 	}
 	for site, since := range want {
 		if got[site] != since {
 			t.Fatalf("RefusingSince[%s] = %d, want %d (got %v)", site, got[site], since, got)
 		}
 	}
 	if _, ok := got["demonic"]; ok {
 		t.Fatalf("RefusingSince names demonic, whose latest pass did not refuse: %v", got)
 	}
 }
 // SidecarOK reads, per Site, the most recent pass that actually reached the
 // sidecar (issue #172): the pass ran its loop (skip '') and no read lost
 // Chrome (unreachable 0). A challenge answer still reached the sidecar, a
 // lost sidecar and every skip value did not, and a Site with no qualifying
 // pass — an asleep Lane included — is absent.
 func TestSidecarOK(t *testing.T) {
 	s := newTestStore(t)
 	seed := func(site string, ranAt int64, skip string, unreachable int) {
 		t.Helper()
 		if err := s.RecordLanePass(LanePass{Site: site, RanAt: ranAt, Skip: skip, Unreachable: unreachable}, -1); err != nil {
 			t.Fatalf("RecordLanePass(%s/%d): %v", site, ranAt, err)
 		}
 	}
 	// comix: only the skip='' unreachable=0 pass reached the sidecar; the
 	// mid-loop browser-loss row (skip '', unreachable > 0) and the skip
 	// values never did.
 	seed("comix", 100, "", 1)
 	seed("comix", 200, "sidecar-down", 0)
 	seed("comix", 300, "", 0)
 	seed("comix", 400, "refusing", 0)
 	// kagane: two passes reached the sidecar; the newest wins.
 	seed("kagane", 150, "", 0)
 	seed("kagane", 250, "", 0)
 	// novelfull: an asleep Lane never reached it.
 	seed("novelfull", 120, "asleep", 0)
 	got, err := s.SidecarOK([]string{"comix", "kagane", "novelfull", "lightnovelworld"})
 	if err != nil {
 		t.Fatalf("SidecarOK: %v", err)
 	}
 	want := map[string]int64{"comix": 300, "kagane": 250}
 	if len(got) != len(want) {
 		t.Fatalf("SidecarOK = %v, want %v", got, want)
 	}
 	for site, ranAt := range want {
 		if got[site] != ranAt {
 			t.Fatalf("SidecarOK[%s] = %d, want %d (got %v)", site, got[site], ranAt, got)
 		}
 	}
 	for _, site := range []string{"novelfull", "lightnovelworld"} {
 		if _, ok := got[site]; ok {
 			t.Fatalf("SidecarOK names %s, which never reached the sidecar: %v", site, got)
 		}
 	}
 }
 // NoChapterShare reads, per Site, the share of its Series holding a
 // no-chapter failure row older than the cutoff (issue #172): old rows over
 // the Site's whole Series count, so a four-Series Site and a 200-Series
 // Site are judged on the same scale. A fresh no-chapter row and a row of
 // any other outcome do not count.
 func TestNoChapterShare(t *testing.T) {
 	s := newTestStore(t)
 	for i := 1; i <= 4; i++ {
 		seedForCheck(t, s, fmt.Sprintf("asura:a%d", i), fmt.Sprintf("https://asurascans.com/comics/a%d", i), 0)
 	}
 	seedForCheck(t, s, "comix:c1", "https://comix.to/title/c1", 0)
 	seedForCheck(t, s, "comix:c2", "https://comix.to/title/c2", 0)
 	seedForCheck(t, s, "demonic:d1", "https://demonicscans.org/series/d1", 0)
 	for i := 1; i <= 200; i++ {
 		seedForCheck(t, s, fmt.Sprintf("novelfull:n%d", i), fmt.Sprintf("https://novelfull.com/n%d.html", i), 0)
 	}
 	const cutoff = 1000
 	oldNoChapter := func(site, seriesID string) {
 		t.Helper()
 		if err := s.RecordSeriesFailure(site, seriesID, "no_chapter", 100); err != nil {
 			t.Fatalf("seed no-chapter failure %s:%s: %v", site, seriesID, err)
 		}
 	}
 	// asura: three of four hold an old no-chapter row; the fourth's
 	// no-chapter row is fresh — it is not old, so it does not count.
 	oldNoChapter("asura", "a1")
 	oldNoChapter("asura", "a2")
 	oldNoChapter("asura", "a3")
 	if err := s.RecordSeriesFailure("asura", "a4", "no_chapter", 2000); err != nil {
 		t.Fatalf("seed fresh no-chapter failure: %v", err)
 	}
 	// comix: an old no-chapter row and an old errors row — the errors row
 	// is not a no-chapter row, so the share is 1/2, the exact boundary.
 	oldNoChapter("comix", "c1")
 	if err := s.RecordSeriesFailure("comix", "c2", "errors", 100); err != nil {
 		t.Fatalf("seed errors failure: %v", err)
 	}
 	// demonic and novelfull: one old no-chapter row each, against sites of
 	// one and two hundred Series.
 	oldNoChapter("demonic", "d1")
 	oldNoChapter("novelfull", "n1")
 	got, err := s.NoChapterShare(cutoff)
 	if err != nil {
 		t.Fatalf("NoChapterShare: %v", err)
 	}
 	checks := []struct {
 		site string
 		want float64
 	}{
 		{"asura", 3.0 / 4.0},
 		{"comix", 1.0 / 2.0},
 		{"demonic", 1.0 / 1.0},
 		{"novelfull", 1.0 / 200.0},
 	}
 	for _, c := range checks {
 		if got[c.site] != c.want {
 			t.Fatalf("NoChapterShare[%s] = %v, want %v", c.site, got[c.site], c.want)
 		}
 	}
 }
@@ -4,16 +4,14 @@ import (
 	"log"
 	"net/http"
 	"strconv"
 	"time"
 	"bookmarkmanager/backend/internal/latest"
 	"bookmarkmanager/backend/internal/store"
 )
 // ownerWindow is the staleness boundary the Series list's "not checked in
-// 12h" filter compares against. It reads latest.OwnerWindow — the one place
+// 12h" filter compares against. Declared once; later admin tickets read it.
-// the class-level twelve hours lives, shared with the owner-notice
+const ownerWindow = 12 * time.Hour
 // conditions (issue #171).
 const ownerWindow = latest.OwnerWindow
 // adminView is the shared shell data for an administrative page and the roster
 // fragment returned after a Reader action.
@@ -49,8 +47,6 @@ func (h *Handler) adminRoutes() []adminRoute {
 		{"GET /admin/series", h.adminSeries},
 		{"GET /admin/series/{key}", h.adminSeriesDetail},
 		{"POST /admin/series/{key}/poll", h.adminSeriesPoll},
 		{"POST /admin/series/{key}/finish", h.adminSeriesFinish},
 		{"POST /admin/series/{key}/unfinish", h.adminSeriesUnfinish},
 		{"POST /admin/series/{key}/latest", h.adminSeriesCorrectLatest},
 		{"POST /admin/series/{key}/series-url", h.adminSeriesSetURL},
 		{"POST /admin/series/{key}/remove", h.adminSeriesRemove},
@@ -56,10 +56,6 @@ type laneRow struct {
 	// offer Resume from the moment the owner presses Pause, with no pass
 	// having run to record it (issue #147).
 	Paused bool
 	// FailingHref is the one navigation the row offers: the Site's name
 	// links to that Site's failing Series. The chips beside it stay
 	// unlinked; the withdrawn promise lives on outcomeChips (issue #167).
 	FailingHref string
 }
 // chip is one named outcome count over the owner's window.
@@ -227,7 +223,6 @@ func buildLaneRow(p store.LanePass, o store.SiteOutcomes, now time.Time) laneRow
 	if p.GapMS > 0 {
 		row.Gap = (time.Duration(p.GapMS) * time.Millisecond).Truncate(time.Second).String()
 	}
 	row.FailingHref = seriesListHref(store.SeriesFilterFailing, p.Site, "", 0)
 	row.Chips = outcomeChips(o)
 	row.HasChips = len(row.Chips) > 0
 	row.StatePhrase, row.StateGood, row.Attention = laneState(p, now)
@@ -237,24 +232,17 @@ func buildLaneRow(p store.LanePass, o store.SiteOutcomes, now time.Time) laneRow
 // outcomeChips lists a Site's nonzero window sums in the taxonomy's fixed
 // order, so the chips never reorder as the window changes. None observed is
-// written by the template, not drawn as a confident zero count. The names are
+// written by the template, not drawn as a confident zero count.
 // spelled through outcomeWord, the one vocabulary the failure surface shares
 // with the Series list's fact line (issue #167). The counts stay unlinked
 // permanently — a withdrawn promise: two of the six words write no per-Series
 // state, and the other four count attempts inside the owner window while the
 // failing filter lists Series failing now, so neither set contains the other
 // and no chip can be a door to its list.
 func outcomeChips(o store.SiteOutcomes) []chip {
 	fixed := []struct {
 		name  string
 		count int
 	}{
-		{outcomeWord("refused"), o.Refused},
+		{"refused", o.Refused},
-		{outcomeWord("unreachable"), o.Unreachable},
+		{"unreachable", o.Unreachable},
-		{outcomeWord("no_chapter"), o.NoChapter},
+		{"no chapter", o.NoChapter},
-		{outcomeWord("unfetchable"), o.Unfetchable},
+		{"unfetchable", o.Unfetchable},
-		{outcomeWord("not_found"), o.NotFound},
+		{"errors", o.Errors},
 		{outcomeWord("errors"), o.Errors},
 	}
 	var out []chip
 	for _, f := range fixed {
@@ -2,10 +2,8 @@ package web
 import (
 	"fmt"
 	"log"
 	"time"
 	"bookmarkmanager/backend/internal/latest"
 	"bookmarkmanager/backend/internal/store"
 )
@@ -25,9 +23,8 @@ type overviewView struct {
 	// as stale + never_checked: a never-checked Series is already counted on
 	// its own filter, and the verdict wants the inclusive number.
 	Unchecked int
-	// Hygiene is the problem filters in the Series list's own render order
+	// Hygiene is the seven problem filters in the Series list's own render
-	// plus the informational tail — finished, then site completed — riding
+	// order; Library is the library split plus the roster. Every figure is a
 	// last; Library is the library split plus the roster. Every figure is a
 	// door into the list that counts it, except a zero.
 	Hygiene []fig
 	Library []fig
@@ -62,13 +59,10 @@ type siteRow struct {
 }
 // overviewView assembles the landing page from the store's read model: one
-// SeriesShapes pass per filter summed in Go (the shipped surface offers ten
+// SeriesShapes pass per filter summed in Go (the shipped surface offers eight
 // grouped passes, not a stats query — #140), the pass log's latest pass per
-// Site, and the roster. A failure in the SeriesShapes, pass or roster reads
+// Site, and the roster. A failure in any read is a 500 with a logged reason,
-// is a 500 with a logged reason, never a page of silent zeroes. The three
+// never a page of silent zeroes.
 // fault-input reads (RefusingSince, SidecarOK, NoChapterShare) fail open:
 // a failing read logs and contributes no fault, so the landing page still
 // renders — the same fail-open the poller uses for owner notices.
 func (h *Handler) overviewView() (overviewView, error) {
 	now := time.Now()
 	cutoff := now.Add(-ownerWindow).UnixMilli()
@@ -97,36 +91,10 @@ func (h *Handler) overviewView() (overviewView, error) {
 	view := overviewView{Waiting: waiting(passes)}
 	view.Unchecked = totals[store.SeriesFilterStale] + totals[store.SeriesFilterNeverChecked]
-	var refusingSince map[string]int64
+	view.Verdict, view.HasCounts = overviewVerdict(passes, now)
 	if m, err := h.store.RefusingSince(now.UnixMilli()); err != nil {
 		log.Printf("admin overview: refusing since: %v", err)
 	} else {
 		refusingSince = m
 	}
 	var sidecarOK map[string]int64
 	if m, err := h.store.SidecarOK(latest.BrowserBackedSites()); err != nil {
 		log.Printf("admin overview: sidecar ok: %v", err)
 	} else {
 		sidecarOK = m
 	}
 	var noChapterShare map[string]float64
 	if m, err := h.store.NoChapterShare(cutoff); err != nil {
 		log.Printf("admin overview: no-chapter share: %v", err)
 	} else {
 		noChapterShare = m
 	}
 	faults := latest.FaultsFrom(latest.FaultInput{
 		Passes:         passes,
 		RefusingSince:  refusingSince,
 		SidecarOK:      sidecarOK,
 		NoChapterShare: noChapterShare,
 	}, now)
 	view.Verdict, view.HasCounts = overviewVerdict(passes, faults)
-	// The hygiene figures, in seriesFilterOrder's tail: the problem filters
+	// The seven problem filters, in seriesFilterOrder's permanent-then-fixable
-	// in permanent-then-fixable order, then the informational tail — finished
+	// order; the All filter's count belongs to the Library block, not to a
 	// and site completed — riding last because seriesFilterOrder appends them
 	// there. The All filter's count belongs to the Library block, not to a
 	// "hygiene" figure.
 	hygiene := make([]fig, 0, len(seriesFilterOrder)-1)
 	for _, name := range seriesFilterOrder[1:] {
@@ -194,26 +162,28 @@ func door(label string, count int, href string) fig {
 	return fig{Label: label, Href: href, Count: count}
 }
-// overviewVerdict decides the landing page's one line: no passes at all is
+// overviewVerdict decides the landing page's one line from the latest pass
-// "no Lane has reported yet" — never confident zeroes; otherwise the count of
+// per Site: no passes at all is "no Lane has reported yet" — never confident
-// faults from the shared FaultsFrom judgement, so the page and the push
+// zeroes; otherwise the count of Lanes whose last pass needs the owner, or
-// cannot disagree. Zero faults is "all lanes healthy". A sidecar-down fault
+// "all lanes healthy". The count comes from the same laneState judgement the
-// carries Site == "" and is still one fault. The Lanes page's per-row
+// Lanes page colours on, so the two pages cannot disagree on what a fault is.
-// laneState is a different question (is this Lane's last pass healthy) from
+func overviewVerdict(passes []store.LanePass, now time.Time) (phrase string, counts bool) {
 // the notice class, and its known false positives live there deliberately, so
 // the two now differ.
 func overviewVerdict(passes []store.LanePass, faults []latest.Fault) (phrase string, counts bool) {
 	if len(passes) == 0 {
 		return "no Lane has reported yet", false
 	}
-	n := len(faults)
+	attention := 0
-	if n == 0 {
+	for _, p := range passes {
 		if _, _, attn := laneState(p, now); attn {
 			attention++
 		}
 	}
 	if attention == 0 {
 		return "all lanes healthy", true
 	}
-	if n == 1 {
+	if attention == 1 {
 		return "1 lane needs a look", true
 	}
-	return fmt.Sprintf("%d lanes need a look", n), true
+	return fmt.Sprintf("%d lanes need a look", attention), true
 }
 // waiting sums Due over the latest pass per Site: how many Series the Lanes
@@ -20,10 +20,10 @@ import (
 // the wrong page. The store does not export it (#140).
 const seriesPageSize = 50
-// seriesFilterLabels names every Series filter for the list select, keyed by
+// seriesFilterLabels names every hygiene filter for the Series list select,
-// the wire constant the URL carries. The render order is seriesFilterOrder;
+// keyed by the wire constant the URL carries. The render order is
-// the labels are read by later admin tickets too, so the map and the
+// seriesFilterOrder; the labels are read by later admin tickets too, so the
-// constants cannot drift apart.
+// map and the constants cannot drift apart.
 var seriesFilterLabels = map[string]string{
 	store.SeriesFilterAll:          "All series",
 	store.SeriesFilterNoURL:        "No series URL",
@@ -33,17 +33,10 @@ var seriesFilterLabels = map[string]string{
 	store.SeriesFilterStale:        "Not checked in 12h",
 	store.SeriesFilterNoCover:      "No cover",
 	store.SeriesFilterReaderReport: "Latest from a Reader",
 	store.SeriesFilterFailing:       "Failing over 12h",
 	store.SeriesFilterUnverified:    "Unverified Reader number",
 	store.SeriesFilterFinished:      "Finished",
 	store.SeriesFilterSiteCompleted: "Site says completed",
 }
 // seriesFilterOrder is the select's render order: All first, then the
-// permanent repairs, then the fixable ones (issue #140). Finished and the
+// permanent repairs, then the fixable ones (issue #140).
 // site-completed hint ride the tail — deliberate, not repairs — and the
 // Overview's stats block renders the same tail, which is what sits the
 // finished and site-completed figures last there.
 var seriesFilterOrder = []string{
 	store.SeriesFilterAll,
 	store.SeriesFilterNoURL,
@@ -53,10 +46,6 @@ var seriesFilterOrder = []string{
 	store.SeriesFilterStale,
 	store.SeriesFilterNoCover,
 	store.SeriesFilterReaderReport,
 	store.SeriesFilterFailing,
 	store.SeriesFilterUnverified,
 	store.SeriesFilterFinished,
 	store.SeriesFilterSiteCompleted,
 }
 // seriesListView is the Series list page's data. The template renders strings
@@ -121,16 +110,6 @@ type seriesRowView struct {
 	// raced answer: the row stays and says a fresh Bookmark caught the press.
 	CanRemove      bool
 	RemovalRefused bool
 	// Finished is the row's display of the owner's finish stamp: the list row
 	// shows the state and never offers the control — that lives on the detail
 	// page, where a press that retires a Series from the Lane is on purpose
 	// and confirm-gated (issue #158).
 	Finished bool
 	// Failure names the standing failure and how long it has stood — "not
 	// found · 3d ago", "" while no failure row stands. Its own field, never a
 	// Notes chip: the chips cap at two plus a tail, so the one fact that
 	// names the failure would be the most likely to be truncated away.
 	Failure string
 }
 // adminSeries renders the filterable, bookmarkable Series list: filter, Site,
@@ -203,96 +182,6 @@ func (h *Handler) adminSeriesPoll(w http.ResponseWriter, r *http.Request) {
 	h.render(w, http.StatusOK, "series-row", seriesRow(a, band, time.Now()))
 }
 // adminSeriesFinish is the owner's Finish control: it stamps the Series'
 // finished_at and answers with the freshly rendered meta fragment, so the
 // "finished <age> ago" line describes the state after the press. The Lane's
 // next pass reads the stamp and stops polling the Series (issue #157). The
 // owner gate is the route's, not this handler's; the body is capped like the
 // API path caps its bodies; the key is validated here — a malformed key is a
 // 400 and an unknown one a 404.
 func (h *Handler) adminSeriesFinish(w http.ResponseWriter, r *http.Request) {
 	site, seriesID, ok := strings.Cut(r.PathValue("key"), ":")
 	if !ok || site == "" || seriesID == "" {
 		http.Error(w, "bad series key", http.StatusBadRequest)
 		return
 	}
 	r.Body = http.MaxBytesReader(w, r.Body, 1<<16)
 	if err := r.ParseForm(); err != nil {
 		http.Error(w, "invalid form", http.StatusBadRequest)
 		return
 	}
 	if _, found, err := h.adminSeriesByKey(site, seriesID); err != nil {
 		log.Printf("series finish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	} else if !found {
 		http.NotFound(w, r)
 		return
 	}
 	if err := h.store.SetSeriesFinished(site, seriesID, time.Now().UnixMilli()); err != nil {
 		log.Printf("series finish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
 	// Re-read after the stamp: the answer must describe the state after the
 	// press, so the line reads "finished just now". The control's one caller
 	// is the detail page, which swaps the meta fragment in place.
 	a, found, err := h.adminSeriesByKey(site, seriesID)
 	if err != nil {
 		log.Printf("series finish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
 	if !found {
 		http.NotFound(w, r)
 		return
 	}
 	h.render(w, http.StatusOK, "series-detail-meta", h.seriesDetailView(a))
 }
 // adminSeriesUnfinish is the reversal of the Finish control: it clears the
 // stamp (writes zero) and answers with the freshly rendered meta fragment, so
 // the Series is back in the Lane's queue from its next pass. Reversal, so it
 // fires instantly with no confirm row (issue #158).
 func (h *Handler) adminSeriesUnfinish(w http.ResponseWriter, r *http.Request) {
 	site, seriesID, ok := strings.Cut(r.PathValue("key"), ":")
 	if !ok || site == "" || seriesID == "" {
 		http.Error(w, "bad series key", http.StatusBadRequest)
 		return
 	}
 	r.Body = http.MaxBytesReader(w, r.Body, 1<<16)
 	if err := r.ParseForm(); err != nil {
 		http.Error(w, "invalid form", http.StatusBadRequest)
 		return
 	}
 	if _, found, err := h.adminSeriesByKey(site, seriesID); err != nil {
 		log.Printf("series unfinish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	} else if !found {
 		http.NotFound(w, r)
 		return
 	}
 	if err := h.store.SetSeriesFinished(site, seriesID, 0); err != nil {
 		log.Printf("series unfinish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
 	// Re-read after the write: the answer must describe the state after the
 	// press, so the fragment no longer carries the finished line.
 	a, found, err := h.adminSeriesByKey(site, seriesID)
 	if err != nil {
 		log.Printf("series unfinish %s: %v", site+":"+seriesID, err)
 		http.Error(w, "internal error", http.StatusInternalServerError)
 		return
 	}
 	if !found {
 		http.NotFound(w, r)
 		return
 	}
 	h.render(w, http.StatusOK, "series-detail-meta", h.seriesDetailView(a))
 }
 // adminSeriesCorrectLatest is the Latest Chapter correction: the owner types
 // one number and the Series' Latest Chapter becomes it, stamped as a
 // Correction. The number must be a finite float greater than zero — a
@@ -627,9 +516,9 @@ func (h *Handler) seriesListView(r *http.Request) (seriesListView, error) {
 	return view, nil
 }
-// seriesFilterOptions renders every filter with its library-wide count, one
+// seriesFilterOptions renders every hygiene filter with its library-wide
-// SeriesShapes pass per filter summed in Go — the shipped surface offers nine
+// count, one SeriesShapes pass per filter summed in Go — the shipped surface
-// grouped passes, not a single stats query (#140). The counts
+// offers eight grouped passes, not a single stats query (#140). The counts
 // are library-wide because the select sits next to the Site narrowing and
 // must not shift as the owner narrows the list itself. Cutoff travels with
 // the stale filter, or its count would always be zero.
@@ -683,7 +572,6 @@ func seriesRow(a store.AdminSeries, i int, now time.Time) seriesRowView {
 		CanRemove: a.ReaderCount == 0,
 		Pending:   pending,
 		Requested: requested,
 		Finished:  a.FinishedAt > 0,
 	}
 	if a.LatestChapterNum != nil {
 		row.Ch = strconv.FormatFloat(*a.LatestChapterNum, 'f', -1, 64)
@@ -691,9 +579,6 @@ func seriesRow(a store.AdminSeries, i int, now time.Time) seriesRowView {
 		row.Ch = "—"
 	}
 	row.Age = checkedAge(now, a.LatestCheckedAt)
 	if a.FailureOutcome != "" {
 		row.Failure = outcomeWord(a.FailureOutcome) + " · " + checkedAge(now, a.FailingSince)
 	}
 	notes := seriesNotes(a, now)
 	if n := len(notes); n > 2 {
 		row.Notes, row.More = notes[:2], n-2
@@ -704,20 +589,6 @@ func seriesRow(a store.AdminSeries, i int, now time.Time) seriesRowView {
 	return row
 }
 // outcomeWord spells the wire failure word as the Lanes chips spell it — a
 // space, not the underscore: not_found reads "not found", no_chapter "no
 // chapter". The remaining words are their own spelling, so an unknown word
 // degrades to itself rather than vanishing from the page.
 func outcomeWord(wire string) string {
 	switch wire {
 	case "not_found":
 		return "not found"
 	case "no_chapter":
 		return "no chapter"
 	}
 	return wire
 }
 // seriesNotes are a row's hygiene chips in the design's order: no URL, no
 // cover, orphan, stale, reader sighting.
 func seriesNotes(a store.AdminSeries, now time.Time) []string {
@@ -56,23 +56,6 @@ type seriesDetailView struct {
 	// Series no Reader holds can be removed, so the owner is never offered a
 	// button the database will always refuse.
 	CanRemove bool
 	// Finished is the owner's finish stamp rendered for the control: while it
 	// stands, the page offers the instant Un-finish, not the confirm-gated
 	// Finish (issue #158).
 	Finished bool
 	// FinishedSince is the "finished <age> ago" line, "" while no finish
 	// stands. It rides the meta fragment both presses swap, so the answer
 	// itself shows how long the Series has been finished.
 	FinishedSince string
 	// Unverified is the sentence beside the Latest Chapter correction
 	// control while a Reader's number stands behind a failure past the
 	// owner window: the value is unconfirmed and the owner should not trust
 	// it. It never names the Reader. "" otherwise.
 	Unverified string
 	// SiteCompleted is the hint's line, "" while the Site has said nothing or
 	// the owner has finished the Series: "the site says this work is
 	// completed (since 3d ago)". A hint, never a control (issue #170).
 	SiteCompleted string
 }
 // adminSeriesDetail renders one Series' page, keyed by the composite
@@ -158,19 +141,6 @@ func (h *Handler) seriesDetailView(a store.AdminSeries) seriesDetailView {
 		v.Checked = since(time.Now(), time.UnixMilli(a.LatestCheckedAt))
 	}
 	v.Corrected = correctedAge(time.Now(), a.LatestCorrectedAt)
 	v.Finished = a.FinishedAt != 0
 	v.FinishedSince = finishedAge(time.Now(), a.FinishedAt)
 	// Unverified: a Reader's number standing behind a failure that has outlived
 	// the owner window is a number nobody has re-checked since — say so next to
 	// the correction control, without naming the Reader. A machine read or a
 	// failure still inside the window carries no sentence; the failure itself
 	// has not yet outlived the twelve hours' worth of trust.
 	if a.RaisedByReader && a.FailureOutcome != "" && a.FailingSince < time.Now().Add(-ownerWindow).UnixMilli() {
 		v.Unverified = "Unverified Reader number: the page has been failing for over 12h, so this Reader-reported chapter is unconfirmed."
 	}
 	if a.SiteCompletedAt != 0 && a.FinishedAt == 0 {
 		v.SiteCompleted = "the site says this work is completed (since " + checkedAge(time.Now(), a.SiteCompletedAt) + ")"
 	}
 	// Provenance: the actor class behind the current number, evaluated in the
 	// order the classes outrank one another — the owner's stamp, which a
@@ -201,13 +171,3 @@ func correctedAge(now time.Time, at int64) string {
 	}
 	return "corrected " + since(now, time.UnixMilli(at))
 }
 // finishedAge is the finish marker's text: "finished <age> ago" while the
 // stamp is set, "" when zero — zero means never finished, and the reversal
 // (un-finish) must not read as history after a press (issue #158).
 func finishedAge(now time.Time, at int64) string {
 	if at == 0 {
 		return ""
 	}
 	return "finished " + since(now, time.UnixMilli(at))
 }
@@ -653,22 +653,6 @@
  margin-left: auto;
 }
 /* The finish confirm is the one calm row on the admin sheet: a reversible
   move wears the recessed ash, never the remove wash above, and its
   affirmative takes the sheet's patina accent (issue #158). */
 .admin-sheet .confirm-row.calm {
  background: var(--ash);
 }
 .admin-sheet .confirm-row.calm span {
  color: var(--paper-dim);
 }
 .admin-sheet .confirm-row.calm .go {
  background: var(--patina);
  color: var(--ink);
 }
 .admin-sheet .tbl.series .row-msg {
  grid-column: 1 / -1;
  margin-top: 6px;
@@ -61,7 +61,7 @@ function setActiveTab(el) {
  document.dispatchEvent(new Event("bmgr:refilter"));
 }
-// The chapter-edit form and the archive/remove confirm rows are the
+// The chapter-edit form and the archive/finish/remove confirm rows are the
 // per-card disclosure panels; only one makes sense open at a time. The button
 // that owns an open panel carries .open, which is how the strip shows which
 // cell the panel belongs to.
@@ -97,10 +97,10 @@ function toggleChapterForm(key) {
  if (form && !form.hidden) form.querySelector("input").focus();
 }
-// kind is "archive" | "remove" — the panel id and the owning action
+// kind is "archive" | "finish" | "remove" — the panel id and the owning action
 // cell share it.
 function toggleConfirmRow(key, kind) {
-  var cls = { archive: ".box", remove: ".remove" }[kind];
+  var cls = { archive: ".box", finish: ".finish", remove: ".remove" }[kind];
  var row = togglePanel(key, "confirm-" + kind + "-" + key, ".actions " + cls);
  // Focus the answer rather than trusting aria-live on a container that merely
  // unhides: it makes the announcement deterministic, keeps tab order inside
@@ -54,7 +54,7 @@
  --ink: #100f0e;          /* page */
  --ash: #161413;          /* recessed panel (chapter form) */
-  --dim: #0d0c0b;          /* archived rows sink */
+  --dim: #0d0c0b;          /* archived / finished rows sink */
  --rule: #221f1d;         /* hairline between sheets */
  --rule-soft: #1a1817;    /* measure edges */
  --field-line: #2c2926;
@@ -550,7 +550,6 @@ button { cursor: pointer; }
 .new-chapter { color: var(--ember); }
 .state { display: flex; align-items: center; gap: 4px; color: var(--mute); }
 .state svg { width: 10px; height: 10px; }
 .state.finished { color: var(--moss); }
 .is-dim .meta { color: var(--mute-2); }
 .is-dim .site-asura, .is-dim .site-demonic,
 .is-dim .site-comix, .is-dim .site-kagane,
@@ -613,13 +612,13 @@ button { cursor: pointer; }
 .actions > *:last-child { border-right: none; }
 .actions svg { width: 17px; height: 17px; }
 .actions > *:hover { color: var(--paper); }
-/* Per-action accent on hover and press: gold favourite, slate archive, clay
+/* Per-action accent on hover and press: gold favourite, slate archive, moss
-   chapter. Remove keeps --danger, play keeps paper/ember. */
+   finished, clay chapter. Remove keeps --danger, play keeps paper/ember. */
 .actions .fav:hover, .actions .fav:active, .actions .fav:focus-visible { color: var(--brass); }
 .actions .pencil:hover, .actions .pencil:active, .actions .pencil:focus-visible { color: var(--clay); }
 .actions .box:hover, .actions .box:active, .actions .box:focus-visible { color: var(--slate); }
 .actions .finish:hover, .actions .finish:active, .actions .finish:focus-visible { color: var(--moss); }
 .actions .play { color: var(--paper); }
 .is-new .actions .play { color: var(--ember); }
 .actions .play:hover { background: var(--hover); }
 .actions .on { color: var(--brass); }
@@ -633,8 +632,8 @@ button { cursor: pointer; }
 .actions .remove.open { background: var(--danger-wash); color: var(--danger); }
 .is-dim .actions > * { color: var(--mute-2); }
-/* Two clusters by consequence: navigate (play) | organize (favourite,
+/* Three clusters by consequence: navigate (play) | organize (favourite,
-   chapter) | lifecycle (archive/restore, remove). The lifecycle cells
+   chapter) | lifecycle (archive/restore, finish, remove). The lifecycle cells
   sit on a recessed ground so the thumb reads "this one moves the series"
   before it reads which icon it landed on. */
 .actions > .lifecycle { background: var(--ash); }
@@ -713,7 +712,7 @@ button { cursor: pointer; }
  color: var(--danger-ink);
  font-weight: 600;
 }
-/* Archive is reversible, so its confirm asks in grey — only the
+/* Archive and finish are reversible, so their confirm asks in grey — only the
   irreversible remove gets the danger wash. */
 .confirm-row.calm { background: var(--ash); }
 .confirm-row.calm span { color: var(--paper-dim); }
@@ -918,7 +917,9 @@ button { cursor: pointer; }
  /* The cell border follows the icon on hover, so the accent reads as a state
     rather than a stray colour. */
  .actions .fav:hover, .actions .pencil:hover,
-  .actions .box:hover { border-color: currentColor; }
+  .actions .box:hover, .actions .finish:hover { border-color: currentColor; }
  /* Panels line up with the body text, i.e. past the cover and its gap. */
  .chapter-form, .confirm-row, .error-inline {
    margin-left: calc(var(--cover-w) + var(--row-gap));
  }
@@ -71,6 +71,10 @@
       {{if eq .Tab "archived"}}aria-current="page"{{end}}
       hx-get="{{.ListURL "archived"}}" hx-target="#list" hx-swap="innerHTML"
       hx-push-url="{{.PageURL "archived"}}" hx-on::after-request="setActiveTab(this)">Archived</a>
    <a href="{{.PageURL "finished"}}" class="{{if eq .Tab "finished"}}active{{end}}"
       {{if eq .Tab "finished"}}aria-current="page"{{end}}
       hx-get="{{.ListURL "finished"}}" hx-target="#list" hx-swap="innerHTML"
       hx-push-url="{{.PageURL "finished"}}" hx-on::after-request="setActiveTab(this)">Finished</a>
  </nav>
  </div>
@@ -1,6 +1,6 @@
 {{define "card"}}
 {{/* One sheet per series. is-new turns the title crimson over an ember rule;
-     is-dim sinks archived rows into italic grey. */}}
+     is-dim sinks archived and finished rows into italic grey. */}}
 <article class="card{{if eq .Status "reading"}}{{if .HasNewChapter}} is-new{{end}}{{else}} is-dim{{end}}"
         id="card-{{.Key}}" data-title="{{.Title}}">
  <div class="row">
@@ -32,10 +32,9 @@
        {{if eq .Status "archived"}}
        <span class="sep">/</span>
        <span class="state">archived</span>
-        {{end}}
+        {{else if eq .Status "finished"}}
        {{if .Finished}}
        <span class="sep">/</span>
-        <span class="state finished">finished</span>
+        <span class="state"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-check"/></svg>finished</span>
        {{end}}
      </p>
    </div>
@@ -57,7 +56,7 @@
        <svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-pencil"/></svg>
      </button>
      {{/* Restore is a reversal, so it fires straight away; every move *out* of
-           the list (archive, remove) goes through a confirm row. */}}
+           the list (archive, finish, remove) goes through a confirm row. */}}
      {{if eq .Status "reading"}}
      <button class="lifecycle box" title="Archive" aria-label="Archive"
              aria-expanded="false" aria-controls="confirm-archive-{{.Key}}"
@@ -72,6 +71,13 @@
        <svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-undo"/></svg>
      </button>
      {{end}}
      {{if ne .Status "finished"}}
      <button class="lifecycle finish" title="Mark finished" aria-label="Mark finished"
              aria-expanded="false" aria-controls="confirm-finish-{{.Key}}"
              onclick="toggleConfirmRow('{{.Key}}', 'finish')">
        <svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-check"/></svg>
      </button>
      {{end}}
      <button class="lifecycle remove" title="Remove" aria-label="Remove"
              aria-expanded="false" aria-controls="confirm-remove-{{.Key}}"
              onclick="toggleConfirmRow('{{.Key}}', 'remove')">
@@ -110,6 +116,18 @@
    </div>
  </div>
  {{end}}
  {{if ne .Status "finished"}}
  <div class="confirm-row calm" id="confirm-finish-{{.Key}}" role="group" aria-live="polite" hidden>
    <span>Mark finished?</span>
    <div>
      <button class="go"
              hx-post="/ui/bookmarks/{{.Key}}/status" hx-vals='{"status":"finished"}'
              hx-target="[id='card-{{.Key}}']" hx-swap="outerHTML"
              hx-indicator="[id='card-{{.Key}}']" hx-disabled-elt="this">Finish</button>
      <button type="button" onclick="toggleConfirmRow('{{.Key}}', 'finish')">Cancel</button>
    </div>
  </div>
  {{end}}
  <div class="confirm-row" id="confirm-remove-{{.Key}}" role="group" aria-live="polite" hidden>
    <span>Remove “{{.Title}}”? Chapter progress is lost.</span>
    <div>
@@ -29,17 +29,21 @@
 {{/* The action key. The icon strip on a card is unlabelled, so one permanent
     line under the tabs names every glyph. It follows the tab rather than the
-     row: the archived bucket swaps Archive for Restore. */}}
+     row: the archived and finished buckets swap Archive for Restore, and a
     finished series has no Done to offer. */}}
 {{define "keyrow"}}
 <div class="keyrow" id="keyrow" aria-label="Action key"{{if .OOB}} hx-swap-oob="true"{{end}}>
  <span class="pair"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-play"/></svg><span>Read</span></span>
  <span class="pair brass"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-star"/></svg><span>Fav</span></span>
  <span class="pair"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-pencil"/></svg><span>Chapter</span></span>
-  {{if eq .Tab "archived"}}
+  {{if or (eq .Tab "archived") (eq .Tab "finished")}}
  <span class="pair"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-undo"/></svg><span>Restore</span></span>
  {{else}}
  <span class="pair"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-box"/></svg><span>Archive</span></span>
  {{end}}
  {{if ne .Tab "finished"}}
  <span class="pair"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-check"/></svg><span>Done</span></span>
  {{end}}
  <span class="pair trash"><svg viewBox="0 0 24 24" aria-hidden="true"><use href="#i-trash"/></svg><span>Delete</span></span>
 </div>
 {{end}}
@@ -7,6 +7,7 @@
  <symbol id="i-star-on" viewBox="0 0 24 24"><path d="M12 3.6l2.6 5.6 6 .8-4.4 4.2 1.1 6-5.3-2.9-5.3 2.9 1.1-6-4.4-4.2 6-.8z" fill="currentColor" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"/></symbol>
  <symbol id="i-pencil" viewBox="0 0 24 24"><path d="M4 20h4L19 9l-4-4L4 16z" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"/></symbol>
  <symbol id="i-box" viewBox="0 0 24 24"><path d="M3 7h18v4H3zM5 11v9h14v-9M10 15h4" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linejoin="round"/></symbol>
  <symbol id="i-check" viewBox="0 0 24 24"><path d="M4 12.5l5.2 5.5L20 6.5" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></symbol>
  <symbol id="i-trash" viewBox="0 0 24 24"><path d="M4 7h16M9.5 7V4h5v3M6.5 7l1 13h9l1-13M10.5 11v6M13.5 11v6" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round"/></symbol>
  <symbol id="i-undo" viewBox="0 0 24 24"><path d="M4 9h9.5a5 5 0 010 10H8M4 9l4.2-4.2M4 9l4.2 4.2" fill="none" stroke="currentColor" stroke-width="1.7" stroke-linecap="round" stroke-linejoin="round"/></symbol>
  <symbol id="i-search" viewBox="0 0 24 24"><circle cx="10.5" cy="10.5" r="6.5" fill="none" stroke="currentColor" stroke-width="1.8"/><path d="M15.3 15.3L20 20" fill="none" stroke="currentColor" stroke-width="1.8" stroke-linecap="round"/></symbol>
@@ -26,7 +26,7 @@
    </div>
    {{range .Rows}}
    <div class="trow{{if .Attention}} attention{{end}}">
-      <a class="c-site" href="{{.FailingHref}}">{{.Site}}</a>
+      <span class="c-site">{{.Site}}</span>
      <span>{{.Due}}</span>
      <span>{{.Checked}}</span>
      <span>{{.Gap}}</span>
@@ -14,6 +14,8 @@
  <div class="empty"><strong>Nothing new.</strong><p>Every series is caught up to its latest chapter.</p></div>
 {{else if eq .Tab "archived"}}
  <div class="empty"><strong>Nothing archived.</strong><p>Shelve a series to park it here — it keeps getting checked for new chapters.</p></div>
 {{else if eq .Tab "finished"}}
  <div class="empty"><strong>Nothing finished yet.</strong><p>Mark a series finished and it moves out of your reading list.</p></div>
 {{else if .EmptyLibrary}}
  {{/* Nothing in either library, so the links are the only thing this page can
       usefully say. Both scripts: the two libraries are separate installs. */}}
@@ -19,7 +19,6 @@
      <input type="number" name="chapter" step="any" placeholder="{{.Chapter}}" required>
      <button type="submit" class="ghost">Set</button>
    </div>
    {{if .Unverified}}<p class="hint">{{.Unverified}}</p>{{end}}
  </form>
  <form class="dform" hx-post="/admin/series/{{.Key}}/series-url" hx-target="#detail-meta" hx-swap="outerHTML">
    <h3>Repair series URL</h3>
@@ -40,23 +39,6 @@
  <div class="field"><button class="ghost danger" hx-post="/admin/series/{{.Key}}/remove" hx-target="#detail-meta" hx-confirm="Removes this series and its stored cover. No Reader has it bookmarked; one re-bookmarking it recreates the row.">Remove</button></div>
 </div>
 {{end}}
 {{if .Finished}}
 <div class="dform">
  <div class="field"><button type="button" class="ghost" hx-post="/admin/series/{{.Key}}/unfinish" hx-target="#detail-meta" hx-swap="outerHTML">Un-finish</button></div>
 </div>
 {{else}}
 <div class="dform">
  <div class="field"><button type="button" class="ghost" onclick="document.getElementById('confirm-finish').hidden = false">Finish</button></div>
  {{if .SiteCompleted}}<p class="hint">{{.SiteCompleted}}</p>{{end}}
  <div class="confirm-row calm" id="confirm-finish" role="group" aria-live="polite" hidden>
    <span>Mark this Series finished?</span>
    <div>
      <button type="button" class="go" hx-post="/admin/series/{{.Key}}/finish" hx-target="#detail-meta" hx-swap="outerHTML">Finish</button>
      <button type="button" onclick="document.getElementById('confirm-finish').hidden = true">Cancel</button>
    </div>
  </div>
 </div>
 {{end}}
 {{end}}
 {{/* series-detail-meta is the meta line, and the answer a Check now or
@@ -72,7 +54,6 @@
  <span>{{.Readers}} readers</span>
  {{if .Corrected}}<span class="mark">{{.Corrected}}</span>{{end}}
  {{if .Pending}}<span class="mark">{{.Requested}}</span>{{end}}
  {{if .FinishedSince}}<span class="mark">{{.FinishedSince}}</span>{{end}}
  {{if .Unpollable}}<span class="mark">unpollable</span>{{end}}
  {{if .NoCover}}<span class="mark">no cover</span>{{end}}
  {{if .Orphan}}<span class="mark">orphan</span>{{end}}
@@ -47,7 +47,7 @@
  <span class="c-ch">{{.Ch}}</span>
  <span>{{.Age}}</span>
  <span class="c-rd">{{.Readers}}</span>
-  <span class="c-note">{{if .Failure}}<span class="mark">{{.Failure}}</span>{{end}}{{range .Notes}}<span class="mark">{{.}}</span>{{end}}{{if .More}}<span class="mark mark-faint">+{{.More}}</span>{{end}}{{if .Finished}}<span class="mark mark-faint">finished</span>{{end}}</span>
+  <span class="c-note">{{range .Notes}}<span class="mark">{{.}}</span>{{end}}{{if .More}}<span class="mark mark-faint">+{{.More}}</span>{{end}}</span>
  <span class="c-act">{{if .CanPoll}}<a class="ghost act" hx-post="/admin/series/{{.Key}}/poll" hx-target="closest .trow" hx-swap="outerHTML" hx-vals='{"band":{{if .Band}}1{{else}}0{{end}}}' href="#">Check now</a>{{end}}{{if .CanRemove}}<button class="ghost danger" hx-post="/admin/series/{{.Key}}/remove" hx-target="closest .trow" hx-swap="outerHTML" hx-include="#filterbar" hx-vals='{"band":{{if .Band}}1{{else}}0{{end}}}' hx-confirm="Removes this series and its stored cover. No Reader has it bookmarked; one re-bookmarking it recreates the row.">Remove</button>{{end}}</span>
  {{if .RemovalRefused}}<span class="row-msg">a Reader has bookmarked this Series again</span>{{end}}
 </div>
@@ -293,11 +293,10 @@ func libOf(q string) string {
 // buildListView loads one reader's list once and derives both the tab-filtered
 // items and the recent strip from it.
 //
-// Archived series appear in their own tab and nowhere else — not in All, not
+// Archived and finished series appear in their own tab and nowhere else — not
-// in Updated, not in Favourites, and not in the recent strip. An archived
+// in All, not in Updated, not in Favourites, and not in the recent strip. An
-// favourite therefore shows only under Archived: Favourites means "favourites
+// archived favourite therefore shows only under Archived: Favourites means
-// I am currently reading". There is no Finished tab: finished is a fact about
+// "favourites I am currently reading".
 // the Series, not a bookmark bucket (issue #157).
 func (h *Handler) buildListView(readerID int64, lib, tab string) (listView, error) {
 	all, err := h.store.List(readerID) // already ordered updated_at DESC
 	if err != nil {
@@ -328,6 +327,8 @@ func (h *Handler) buildListView(readerID int64, lib, tab string) (listView, erro
 		items = withNew
 	case "archived":
 		items = filterBookmarks(all, func(b store.Bookmark) bool { return b.Status == store.StatusArchived })
 	case "finished":
 		items = filterBookmarks(all, func(b store.Bookmark) bool { return b.Status == store.StatusFinished })
 	default:
 		tab = "all"
 		items = reading
@@ -391,7 +392,7 @@ func currentLib(r *http.Request) string {
 // writeChromeOOB appends the regions that live outside #list — the recent
 // strip, the Updated badge and the action key — as out-of-band swaps, so a
 // mutation cannot leave them describing the library as it was before the tap.
-// The key is in here because it is tab-shaped too: the archived bucket swaps
+// The key is in here because it is tab-shaped too: archived and finished swap
 // Archive for Restore.
 func (h *Handler) writeChromeOOB(w http.ResponseWriter, view listView) {
 	view.OOB = true
@@ -491,9 +492,9 @@ func (h *Handler) uiFavorite(w http.ResponseWriter, r *http.Request) {
 	h.saveAndRenderCard(w, r, b)
 }
-// uiStatus moves a bookmark between the two lifecycle buckets. Finished is not
+// uiStatus moves a bookmark between lifecycle buckets. This is the only place
-// one of them: it is a fact about the Series, decided from the admin surface,
+// a series can be marked finished — the JSON API refuses that value, so the
-// so the web UI's per-bookmark control cannot set it (issue #157).
+// userscript cannot set it even by accident.
 //
 // last_chapter_num is untouched, so Upsert keeps the stored updated_at and the
 // list does not reorder.
@@ -507,7 +508,7 @@ func (h *Handler) uiStatus(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 	switch s := r.PostFormValue("status"); s {
-	case store.StatusReading, store.StatusArchived:
+	case store.StatusReading, store.StatusArchived, store.StatusFinished:
 		b.Status = s
 	default:
 		http.Error(w, "invalid status", http.StatusBadRequest)
@@ -14,7 +14,6 @@ import (
 	"bookmarkmanager/backend/internal/api"
 	"bookmarkmanager/backend/internal/httpmw"
 	"bookmarkmanager/backend/internal/latest"
 	"bookmarkmanager/backend/internal/notify"
 	"bookmarkmanager/backend/internal/store"
 	"bookmarkmanager/backend/internal/token"
 	"bookmarkmanager/backend/internal/userscript"
@@ -60,12 +59,6 @@ type Config struct {
 	// the Lanes page reports the fact and derives reachability from the pass
 	// log rather than asking the poller (issue #145).
 	BrowserWSURL string
 	// DiscordWebhookURL is the webhook owner notices post to (issue #171).
 	// Unset means the whole path is off — a local stack needs no webhook,
 	// exactly as the browser URL behaves. The address is a secret in the
 	// class of TOKEN_KEY: never logged, and it must not reach any line that
 	// prints configuration.
 	DiscordWebhookURL string
 	// LatestPoll configures the background latest-chapter fetcher.
 	LatestPoll LatestPoll
 }
@@ -121,7 +114,6 @@ func loadConfig() Config {
 		UserscriptPath:      envOr("USERSCRIPT_PATH", "/userscript/manga-bookmark.user.js"),
 		NovelUserscriptPath: envOr("NOVEL_USERSCRIPT_PATH", "/userscript/novel-bookmark.user.js"),
 		BrowserWSURL:        os.Getenv("BROWSER_WS_URL"),
 		DiscordWebhookURL:   os.Getenv("DISCORD_WEBHOOK_URL"),
 		LatestPoll:          loadLatestPoll(),
 	}
 	c.Discord = web.DiscordConfig{
@@ -296,22 +288,10 @@ func main() {
 		}
 		s.OnSeriesCreated = acq.Acquire
 	}
 	// Owner notices (issue #171): a configured webhook makes the poller tell
 	// the owner about stalled Lanes. Unset means the whole path is off — a
 	// local stack needs no webhook, exactly as the browser URL behaves. Only
 	// the presence is logged; the address itself is a secret in the class of
 	// TOKEN_KEY.
 	var notifier latest.Notifier
 	if u := strings.TrimSpace(cfg.DiscordWebhookURL); u != "" {
 		notifier = notify.New(u, cfg.PublicBaseURL)
 		log.Println("owner notices: enabled")
 	} else {
 		log.Println("owner notices: disabled (DISCORD_WEBHOOK_URL unset)")
 	}
 	// The poller's only connection to the web layer is the database now: it is
 	// started for its own sake, and the Lanes page reads the pass rows it
 	// records (issue #145).
-	startLatestPoller(pollCtx, s, cfg.LatestPoll, browser, notifier)
+	startLatestPoller(pollCtx, s, cfg.LatestPoll, browser)
 	srv := &http.Server{
 		Addr:              ":" + cfg.Port,
@@ -344,9 +324,7 @@ func main() {
 // newLatestPoller wires the fetcher seams into the poller. Pace is registry
 // property, not config (issue #100), so there are no knobs to pass through.
-// notifier is nil when no webhook is configured: a missing webhook is a
+func newLatestPoller(s *store.Store, cfg LatestPoll, fetch, browser latest.Fetcher) *latest.Poller {
 // silent off switch, not an error (issue #171).
 func newLatestPoller(s *store.Store, cfg LatestPoll, fetch, browser latest.Fetcher, notifier latest.Notifier) *latest.Poller {
 	var covers latest.BrowserCoverFetcher
 	if f, ok := browser.(latest.BrowserCoverFetcher); ok {
 		covers = f
@@ -357,7 +335,6 @@ func newLatestPoller(s *store.Store, cfg LatestPoll, fetch, browser latest.Fetch
 		BrowserFetch:    browser,
 		CoverFetch:      covers,
 		CoverBytesFetch: latest.NewCoverFetcher(),
 		Notify:          notifier,
 		Now:             time.Now,
 	}
 }
@@ -368,8 +345,7 @@ func newLatestPoller(s *store.Store, cfg LatestPoll, fetch, browser latest.Fetch
 // tracking, which is exactly how it behaved before. It returns the running
 // Poller, or nil when there is none; the caller starts it for its own sake —
 // the Lanes page reads the pass log, so no return value is wired anywhere.
-// notifier is nil when DISCORD_WEBHOOK_URL is unset (issue #171).
+func startLatestPoller(ctx context.Context, s *store.Store, cfg LatestPoll, browser latest.Fetcher) *latest.Poller {
 func startLatestPoller(ctx context.Context, s *store.Store, cfg LatestPoll, browser latest.Fetcher, notifier latest.Notifier) *latest.Poller {
 	if !cfg.Enabled {
 		log.Println("latest-chapter poller: disabled by config")
 		return nil
@@ -382,7 +358,7 @@ func startLatestPoller(ctx context.Context, s *store.Store, cfg LatestPoll, brow
 	// Nil browser: sites behind a JavaScript challenge are simply not polled,
 	// and their latest_chapter comes from the userscript alone — which is how
 	// the service behaved before the sidecar existed.
-	p := newLatestPoller(s, cfg, f, browser, notifier)
+	p := newLatestPoller(s, cfg, f, browser)
 	go p.Run(ctx)
 	return p
@@ -28,20 +28,6 @@ func TestLoadConfigReadsCoverDirectory(t *testing.T) {
 	}
 }
 func TestLoadConfigReadsDiscordWebhook(t *testing.T) {
 	// The address is read, never defaulted: unset stays empty (the whole
 	// path is off), set flows into the Config for the poller's notifier.
 	const url = "https://discord.com/api/webhooks/000000/secret"
 	t.Setenv("DISCORD_WEBHOOK_URL", url)
 	if got := loadConfig().DiscordWebhookURL; got != url {
 		t.Fatalf("DiscordWebhookURL = %q, want %q", got, url)
 	}
 	t.Setenv("DISCORD_WEBHOOK_URL", "")
 	if got := loadConfig().DiscordWebhookURL; got != "" {
 		t.Fatalf("DiscordWebhookURL = %q, want empty when unset", got)
 	}
 }
 func TestLoadLatestPollEnabledParsing(t *testing.T) {
 	tests := []struct {
 		raw  string
@@ -65,8 +51,7 @@ func TestLoadLatestPollEnabledParsing(t *testing.T) {
 // nothing here sizes a cooldown any more.
 func TestNewLatestPollerWiresFetchers(t *testing.T) {
 	tls := &latest.TLSFetcher{}
-	notifier := &stubNotifier{}
+	p := newLatestPoller(nil, LatestPoll{Enabled: true}, tls, nil)
 	p := newLatestPoller(nil, LatestPoll{Enabled: true}, tls, nil, notifier)
 	if p.Fetch != tls {
 		t.Fatalf("Fetch not wired")
 	}
@@ -82,15 +67,8 @@ func TestNewLatestPollerWiresFetchers(t *testing.T) {
 	if p.Now == nil {
 		t.Fatalf("Now = nil, want the live clock")
 	}
 	if p.Notify != notifier {
 		t.Fatalf("Notify = %v, want the configured notifier", p.Notify)
 	}
 }
 // stubNotifier satisfies latest.Notifier so newLatestPoller's wiring can be
 // asserted; it is never called.
 type stubNotifier struct{ latest.Notifier }
 func TestPutStatusValidation(t *testing.T) {
 	cases := []struct {
 		name   string
@@ -100,7 +78,7 @@ func TestPutStatusValidation(t *testing.T) {
 		{"empty is no opinion", "", http.StatusOK},
 		{"reading", "reading", http.StatusOK},
 		{"archived", "archived", http.StatusOK},
-		{"finished is no longer a bucket", "finished", http.StatusBadRequest},
+		{"finished is web-only", "finished", http.StatusBadRequest},
 		{"garbage", "dropped", http.StatusBadRequest},
 	}
 	for _, tc := range cases {
@@ -918,7 +918,7 @@ func TestLanesRenderFromSeededRowsAfterRestart(t *testing.T) {
 	seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.Add(-time.Minute).UnixMilli(), Due: 5, Checked: 5, GapMS: 20_000})
 	body := lanesBody(t, router, st)
-	if !strings.Contains(body, `<a class="c-site" href="/admin/series?filter=failing&amp;site=asura">asura</a>`) {
+	if !strings.Contains(body, `class="c-site">asura</span>`) {
 		t.Fatalf("asura row missing from a restart-read database:\n%s", body)
 	}
 	// The fragment carries its own single timer and answers the swap it asked
@@ -953,32 +953,22 @@ func TestSkipReasonIsNotAStall(t *testing.T) {
 	}
 }
-// The six outcome counts render named — the page never prints the word
+// The five outcome counts render named — the page never prints the word
-// "failures" — in the taxonomy's fixed order, not found beside the word it
+// "failures" — and a Site with none observed says so rather than drawing a
-// split out of. A Site with none observed says so rather than drawing a
+// blank cell.
 // blank cell, and a zero not_found renders no chip of its own.
 func TestNamedOutcomeChips(t *testing.T) {
 	router, st := newWebTestServer(t, lanesConfig())
 	now := time.Now()
-	seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), Refused: 5, Unreachable: 3, NoChapter: 2, Unfetchable: 4, NotFound: 6, Errors: 1})
+	seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), Refused: 5, NoChapter: 2, Errors: 1})
-	seedPass(t, st, store.LanePass{Site: "demonic", RanAt: now.UnixMilli(), Unreachable: 7, Unfetchable: 8})
+	seedPass(t, st, store.LanePass{Site: "demonic", RanAt: now.UnixMilli(), Unreachable: 3, Unfetchable: 4})
 	seedPass(t, st, store.LanePass{Site: "comix", RanAt: now.UnixMilli()})
 	body := lanesBody(t, router, st)
-	for _, want := range []string{"refused 5", "unreachable 3", "no chapter 2", "unfetchable 4", "not found 6", "errors 1"} {
+	for _, want := range []string{"refused 5", "no chapter 2", "errors 1", "unreachable 3", "unfetchable 4"} {
 		if !strings.Contains(body, want) {
 			t.Errorf("lane chips lack %q:\n%s", want, body)
 		}
 	}
 	wantSeq := `<span class="mark">refused 5</span><span class="mark-faint"> · </span><span class="mark">unreachable 3</span><span class="mark-faint"> · </span><span class="mark">no chapter 2</span><span class="mark-faint"> · </span><span class="mark">unfetchable 4</span><span class="mark-faint"> · </span><span class="mark">not found 6</span><span class="mark-faint"> · </span><span class="mark">errors 1</span>`
 	if !strings.Contains(body, wantSeq) {
 		t.Errorf("chips do not render in the fixed order (… unfetchable, not found, errors …):\n%s", body)
 	}
 	// demonic has outcomes but no not_found: exactly one "not found" in the
 	// whole fragment — asura's — so a zero count renders none.
 	if got := strings.Count(body, "not found"); got != 1 {
 		t.Errorf("the word \"not found\" appears %d times, want exactly the one seeded chip", got)
 	}
 	if strings.Contains(body, "failures") {
 		t.Errorf("the page prints the forbidden word \"failures\":\n%s", body)
 	}
@@ -989,31 +979,6 @@ func TestNamedOutcomeChips(t *testing.T) {
 	}
 }
 // Each Site row on the Lanes page carries one plain navigation link to that
 // Site's failing Series — a navigation, not a number: the outcome chips
 // beside it stay unlinked permanently, so the row offers one click and one
 // answer. The clean Site links too, into an empty list (issue #167).
 func TestLaneSiteLinksToFailingSeriesAndChipsStayUnlinked(t *testing.T) {
 	router, st := newWebTestServer(t, lanesConfig())
 	now := time.Now()
 	seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), NotFound: 6})
 	seedPass(t, st, store.LanePass{Site: "demonic", RanAt: now.UnixMilli()})
 	body := lanesBody(t, router, st)
 	if !strings.Contains(body, `<a class="c-site" href="/admin/series?filter=failing&amp;site=asura">asura</a>`) {
 		t.Errorf("the failing Site's name is not a link to its failing Series:\n%s", body)
 	}
 	if !strings.Contains(body, `<a class="c-site" href="/admin/series?filter=failing&amp;site=demonic">demonic</a>`) {
 		t.Errorf("the clean Site's name is not a link to its (empty) failing Series:\n%s", body)
 	}
 	if !strings.Contains(body, `<span class="mark">not found 6</span>`) {
 		t.Errorf("the outcome chip no longer renders beside the link:\n%s", body)
 	}
 	if got := strings.Count(body, `<a class="c-site"`); got != 2 {
 		t.Errorf("Site anchor count = %d, want exactly 2 (only the two Site names navigate):\n%s", got, body)
 	}
 }
 // Browser configuration is a deployment fact and reachability is derived from
 // the latest browser-Site passes inside the refusal backoff — no poller in any
 // of the three.
@@ -1558,8 +1523,8 @@ func TestCardHxTargetIsValidSelectorForColonKey(t *testing.T) {
 	body := rr.Body.String()
 	want := `hx-target="[id='card-asura:solo']"`
-	if strings.Count(body, want) != 4 {
+	if strings.Count(body, want) != 5 {
-		t.Fatalf("body has %d occurrences of %s, want 4 (favorite, archive, delete buttons, chapter form)",
+		t.Fatalf("body has %d occurrences of %s, want 5 (favorite, archive, finish, delete buttons, chapter form)",
 			strings.Count(body, want), want)
 	}
 	if strings.Contains(body, `hx-target="#card-asura:solo"`) {
@@ -1783,6 +1748,8 @@ func seedStatusRows(t *testing.T, st *store.Store) {
 		{Key: "asura:archived", Site: "asura", SeriesID: "archived", Title: "ArchivedOne",
 			Status: store.StatusArchived, LastChapterNum: 5, Favorite: true,
 			LatestChapter: "99", LatestChapterNum: floatPtr(99)},
 		{Key: "asura:finished", Site: "asura", SeriesID: "finished", Title: "FinishedOne",
 			Status: store.StatusFinished, LastChapterNum: 200, Favorite: true},
 	}
 	for _, b := range rows {
 		b.UpdatedAt = time.Now().UnixMilli()
@@ -1791,6 +1758,7 @@ func seedStatusRows(t *testing.T, st *store.Store) {
 		}
 	}
 }
 func TestTabsShowOnlyTheirBucket(t *testing.T) {
 	cfg := testConfig()
 	srv, st := newWebTestServer(t, cfg)
@@ -1800,10 +1768,11 @@ func TestTabsShowOnlyTheirBucket(t *testing.T) {
 		tab            string
 		want, dontWant []string
 	}{
-		{"all", []string{"ReadingOne"}, []string{"ArchivedOne"}},
+		{"all", []string{"ReadingOne"}, []string{"ArchivedOne", "FinishedOne"}},
-		{"new", []string{"ReadingOne"}, []string{"ArchivedOne"}},
+		{"new", []string{"ReadingOne"}, []string{"ArchivedOne", "FinishedOne"}},
-		{"fav", []string{"ReadingOne"}, []string{"ArchivedOne"}},
+		{"fav", []string{"ReadingOne"}, []string{"ArchivedOne", "FinishedOne"}},
-		{"archived", []string{"ArchivedOne"}, []string{"ReadingOne"}},
+		{"archived", []string{"ArchivedOne"}, []string{"ReadingOne", "FinishedOne"}},
 		{"finished", []string{"FinishedOne"}, []string{"ReadingOne", "ArchivedOne"}},
 	}
 	for _, tc := range cases {
 		t.Run(tc.tab, func(t *testing.T) {
@@ -1866,12 +1835,12 @@ func TestRecentStripCarriesUnreadOnlyAndOnlyOnAll(t *testing.T) {
 	if !strings.Contains(strip, "ReadingOne") {
 		t.Fatal("strip dropped the series with an unread chapter")
 	}
-	for _, unwanted := range []string{"CaughtUpOne", "ArchivedOne"} {
+	for _, unwanted := range []string{"CaughtUpOne", "ArchivedOne", "FinishedOne"} {
 		if strings.Contains(strip, unwanted) {
 			t.Fatalf("strip included %s", unwanted)
 		}
 	}
-	for _, tab := range []string{"new", "fav", "archived"} {
+	for _, tab := range []string{"new", "fav", "archived", "finished"} {
 		if strings.Contains(stripOf(t, srv, st, tab), "ReadingOne") {
 			t.Fatalf("tab %s rendered the strip", tab)
 		}
@@ -1934,7 +1903,7 @@ func TestUIStatusSetsBucket(t *testing.T) {
 	srv, st := newWebTestServer(t, cfg)
 	seedStatusRows(t, st)
-	for _, want := range []string{store.StatusArchived, store.StatusReading} {
+	for _, want := range []string{store.StatusArchived, store.StatusFinished, store.StatusReading} {
 		if rr := postStatus(t, srv, st, "asura:reading", want); rr.Code != http.StatusOK {
 			t.Fatalf("set %s: status = %d, body %s", want, rr.Code, rr.Body.String())
 		}
@@ -2002,11 +1971,12 @@ func TestCardShowsStatusControls(t *testing.T) {
 		tab            string
 		want, dontWant []string
 	}{
-		// A series being read can be shelved, not restored, and there is no
+		// A series being read can be shelved or completed, not restored.
-		// finish control any more (issue #157).
+		{"all", []string{`hx-vals='{"status":"archived"}'`, `hx-vals='{"status":"finished"}'`}, nil},
-		{"all", []string{`hx-vals='{"status":"archived"}'`}, []string{`hx-vals='{"status":"finished"}'`}},
+		// An archived one can come back or be completed.
-		// An archived one can come back.
+		{"archived", []string{`hx-vals='{"status":"reading"}'`, `hx-vals='{"status":"finished"}'`}, nil},
-		{"archived", []string{`hx-vals='{"status":"reading"}'`}, []string{`hx-vals='{"status":"finished"}'`}},
+		// A finished one can only come back.
 		{"finished", []string{`hx-vals='{"status":"reading"}'`}, []string{`hx-vals='{"status":"finished"}'`}},
 	}
 	for _, tc := range cases {
 		t.Run(tc.tab, func(t *testing.T) {
@@ -2040,14 +2010,11 @@ func TestAppRendersNewTabs(t *testing.T) {
 	rr := httptest.NewRecorder()
 	srv.ServeHTTP(rr, req)
-	for _, want := range []string{`href="/?tab=archived"`} {
+	for _, want := range []string{`href="/?tab=archived"`, `href="/?tab=finished"`} {
 		if !strings.Contains(rr.Body.String(), want) {
 			t.Fatalf("app page missing %s", want)
 		}
 	}
 	if strings.Contains(rr.Body.String(), `href="/?tab=finished"`) {
 		t.Fatal("app page still offers a Finished tab")
 	}
 }
 // A mutation has to bring the chrome with it: the strip and the badge live
@@ -2164,6 +2131,7 @@ func TestNovelPageOmitsUpdatedTab(t *testing.T) {
 	for _, want := range []string{
 		"/?lib=novel&amp;tab=fav",
 		"/?lib=novel&amp;tab=archived",
 		"/?lib=novel&amp;tab=finished",
 	} {
 		if !strings.Contains(body, want) {
 			t.Fatalf("novel page missing tab link %s", want)
@@ -2220,7 +2188,6 @@ type seriesRowSeed struct {
 	latestNum *float64
 	bookmarks int  // readers that hold it; 0 = orphan
 	raisedBy  bool // a Reader's report is attributed as the raiser
 	siteCompletedAt int64 // the Site's own marker (issue #168), 0 = not set
 }
 // seedSeriesRow inserts one series row and its bookmarks (owner first, then
@@ -2240,10 +2207,10 @@ func seedSeriesRow(t *testing.T, st *store.Store, db *sql.DB, seed seriesRowSeed
 	}
 	if _, err := db.Exec(`
 		INSERT INTO series (site, series_id, title, kind, series_url, cover_address,
-		                    latest_checked_at, latest_chapter, latest_chapter_num, site_completed_at)
+		                    latest_checked_at, latest_chapter, latest_chapter_num)
-		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10)`,
+		VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)`,
 		site, seriesID, "Title of "+seed.key, seed.kind, seed.url, seed.cover,
-		seed.checkedAt, latestChapter, seed.latestNum, seed.siteCompletedAt); err != nil {
+		seed.checkedAt, latestChapter, seed.latestNum); err != nil {
 		t.Fatalf("seed series %q: %v", seed.key, err)
 	}
 	for i := range seed.bookmarks {
@@ -2343,82 +2310,6 @@ func TestSeriesListFilterWiring(t *testing.T) {
 	}
 }
 // The finished filter is a first-class option: the select carries it with
 // its label and library-wide count, and entering it lists exactly the
 // retired rows — picking it up from order-plus-label like every other
 // filter, with no per-filter branch in the handler.
 func TestSeriesListFinishedFilterOption(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:healthy", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(10), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:retired", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	if err := st.SetSeriesFinished("asura", "retired", time.Now().UnixMilli()); err != nil {
 		t.Fatalf("finish asura:retired: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	body := adminSeriesPage(t, srv, st, "?filter=finished")
 	if !strings.Contains(body, "Title of asura:retired") {
 		t.Errorf("finished list misses its row:\n%s", body)
 	}
 	if strings.Contains(body, "Title of asura:healthy") {
 		t.Errorf("finished list renders an unfinished row:\n%s", body)
 	}
 	if !strings.Contains(body, "1 series") || !strings.Contains(body, "Finished") {
 		t.Errorf("finished heading lacks the count and label:\n%s", body)
 	}
 	if !strings.Contains(body, "Finished (1)") {
 		t.Errorf("the finished option lacks its count:\n%s", body)
 	}
 	if !strings.Contains(body, `<option value="finished" selected>`) {
 		t.Errorf("the finished option is not selected:\n%s", body)
 	}
 }
 // The site-completed filter is in the select's vocabulary like any other,
 // and the list it opens shows exactly the hinted Series — the Site's marker
 // with no owner's Finish, because a retired Series is not work a Poll is
 // coming to do (issue #170).
 func TestSeriesListSiteCompletedFilterOption(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	hinted := time.Now().Add(-72 * time.Hour).UnixMilli()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:hinted", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(10), bookmarks: 1, siteCompletedAt: hinted})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:plain", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:retired", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(2), bookmarks: 1, siteCompletedAt: hinted})
 	if err := st.SetSeriesFinished("asura", "retired", time.Now().UnixMilli()); err != nil {
 		t.Fatalf("finish asura:retired: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	body := adminSeriesPage(t, srv, st, "?filter=site_completed")
 	if !strings.Contains(body, "Title of asura:hinted") {
 		t.Errorf("site-completed list misses its row:\n%s", body)
 	}
 	for _, banned := range []string{"Title of asura:plain", "Title of asura:retired"} {
 		if strings.Contains(body, banned) {
 			t.Errorf("site-completed list renders %q:\n%s", banned, body)
 		}
 	}
 	if !strings.Contains(body, "1 series") {
 		t.Errorf("site-completed heading lacks the count:\n%s", body)
 	}
 	if !strings.Contains(body, `Site says completed (1)`) {
 		t.Errorf("the site-completed option lacks its count:\n%s", body)
 	}
 	if !strings.Contains(body, `<option value="site_completed" selected>`) {
 		t.Errorf("the site-completed option is not selected:\n%s", body)
 	}
 }
 // ?filter=stale&site=kagane&kind=manga narrows on all three at once: only the
 // kagane manga stale row renders, and every link the page emits carries the
 // filter and Site so the narrowing survives in the URL.
@@ -2695,44 +2586,6 @@ func TestSeriesListRowShape(t *testing.T) {
 	}
 }
 // The row's fact line names the standing failure and how long it has stood,
 // through one format for every age: a one-hour-old failure and a
 // three-month-old one both render as "<word> · <checkedAge>", and a Series
 // with no failure row renders no marker at all. The marker is its own field,
 // never a Notes chip — the chips cap at two plus a tail, so the failure
 // would be the fact most likely to be truncated away (issue #167).
 func TestSeriesListFailureMarkerAges(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	now := time.Now()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:hour", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:months", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:fine", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	if err := st.RecordSeriesFailure("asura", "hour", "not_found", now.Add(-time.Hour).UnixMilli()); err != nil {
 		t.Fatalf("seed failure row on hour: %v", err)
 	}
 	if err := st.RecordSeriesFailure("asura", "months", "no_chapter", now.Add(-90*24*time.Hour).UnixMilli()); err != nil {
 		t.Fatalf("seed failure row on months: %v", err)
 	}
 	body := adminSeriesPage(t, newRouter(st, testConfig()), st, "")
 	if !strings.Contains(body, `<span class="mark">not found · 1h ago</span>`) {
 		t.Errorf("the one-hour failure lacks its marker:\n%s", body)
 	}
 	if !strings.Contains(body, `<span class="mark">no chapter · 90d ago</span>`) {
 		t.Errorf("the three-month failure lacks its marker:\n%s", body)
 	}
 	// The clean row carries none, and neither word leaks anywhere else on
 	// the page: exactly one marker per failing row.
 	if strings.Count(body, "not found") != 1 || strings.Count(body, "no chapter") != 1 {
 		t.Errorf("failure words appear more than once, or on a clean row:\n%s", body)
 	}
 }
 // The per-Series page renders every Series-level fact the admin read model
 // holds for the key the list row already shows: title, the composite key with
 // Site and kind, the Latest Chapter, the check age and the anonymous Reader
@@ -2872,57 +2725,6 @@ func TestAdminSeriesDetailRendersMarks(t *testing.T) {
 	}
 }
 // The detail page adds one sentence beside the Latest Chapter correction
 // control only while the number came from a Reader and the failure row has
 // stood past the owner window: a Reader-attributed failing Series carries it,
 // a machine-read failing Series does not, and neither does a
 // Reader-attributed Series whose failure is still inside the window. The
 // sentence names no Reader (issue #167).
 func TestAdminSeriesDetailUnverifiedSentence(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	now := time.Now()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:reader-fail", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(2), bookmarks: 1, raisedBy: true})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:machine-fail", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:reader-recent", url: "u", cover: "c", checkedAt: now.UnixMilli(), latestNum: floatPtr(3), bookmarks: 1, raisedBy: true})
 	if err := st.RecordSeriesFailure("asura", "reader-fail", "not_found", now.Add(-24*time.Hour).UnixMilli()); err != nil {
 		t.Fatalf("seed failure row on reader-fail: %v", err)
 	}
 	if err := st.RecordSeriesFailure("asura", "machine-fail", "not_found", now.Add(-24*time.Hour).UnixMilli()); err != nil {
 		t.Fatalf("seed failure row on machine-fail: %v", err)
 	}
 	if err := st.RecordSeriesFailure("asura", "reader-recent", "not_found", now.Add(-time.Hour).UnixMilli()); err != nil {
 		t.Fatalf("seed failure row on reader-recent: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	want := "Unverified Reader number: the page has been failing for over 12h, so this Reader-reported chapter is unconfirmed."
 	fetch := func(key string) string {
 		t.Helper()
 		req := httptest.NewRequest(http.MethodGet, "/admin/series/"+key, nil)
 		req.AddCookie(sessionCookie(t, st))
 		rr := httptest.NewRecorder()
 		srv.ServeHTTP(rr, req)
 		if rr.Code != http.StatusOK {
 			t.Fatalf("GET /admin/series/%s status = %d, want 200", key, rr.Code)
 		}
 		return rr.Body.String()
 	}
 	if body := fetch("asura:reader-fail"); !strings.Contains(body, want) {
 		t.Errorf("a Reader-attributed failing Series lacks the unverified sentence:\n%s", body)
 	}
 	if body := fetch("asura:machine-fail"); strings.Contains(body, want) {
 		t.Errorf("a machine-read failing Series carries the unverified sentence:\n%s", body)
 	}
 	if body := fetch("asura:reader-recent"); strings.Contains(body, want) {
 		t.Errorf("a Reader-attributed Series failing inside the window carries the sentence:\n%s", body)
 	}
 }
 // The provenance line beside the chapter names the actor class behind the
 // value — "machine read" for a checked Series, "correction" for the owner's
 // stamp, "sighting" for a Reader-raised one — and appears nowhere in the
@@ -3099,7 +2901,7 @@ func TestOverviewVerdictThreeStates(t *testing.T) {
 	})
 	t.Run("lanes need a look", func(t *testing.T) {
-		seedPass(t, st, store.LanePass{Site: "demonic", RanAt: now.UnixMilli(), Due: 1, Checked: 0, Skip: "", Refused: 0})
+		seedPass(t, st, store.LanePass{Site: "demonic", RanAt: now.UnixMilli(), Skip: latest.SkipRefusing})
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "1 lane needs a look") {
 			t.Errorf("attention verdict missing:\n%s", body)
@@ -3118,96 +2920,6 @@ func TestOverviewVerdictThreeStates(t *testing.T) {
 	})
 }
 // TestOverviewVerdictFromFaults mirrors the four fault inputs the notifier judges
 // (stall, no-browser-route, sidecar-down, adapter-broken); plus healthy and
 // virgin. Each seeds the durable rows the page reads, with no poller running.
 func TestOverviewVerdictFromFaults(t *testing.T) {
 	t.Run("stall is a fault", func(t *testing.T) {
 		router, st := newWebTestServer(t, testConfig())
 		now := time.Now()
 		seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), Due: 3, Checked: 0, Skip: "", Refused: 0})
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "1 lane needs a look") {
 			t.Errorf("stall fault verdict missing:\n%s", body)
 		}
 	})
 	t.Run("no-browser-route is a fault on plain TLS site", func(t *testing.T) {
 		router, st := newWebTestServer(t, testConfig())
 		old := time.Now().Add(-13 * time.Hour).UnixMilli()
 		seedPass(t, st, store.LanePass{Site: "asura", RanAt: old, Skip: latest.SkipRefusing})
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "1 lane needs a look") {
 			t.Errorf("no-browser-route fault verdict missing:\n%s", body)
 		}
 	})
 	t.Run("sidecar-down is one fault even though every browser lane is down", func(t *testing.T) {
 		router, st := newWebTestServer(t, testConfig())
 		now := time.Now().UnixMilli()
 		for _, site := range []string{"comix", "kagane", "novelfull"} {
 			seedPass(t, st, store.LanePass{Site: site, RanAt: now, Skip: latest.SkipSidecarDown})
 		}
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "1 lane needs a look") {
 			t.Errorf("sidecar-down fault should count as one, want %q:\n%s", "1 lane needs a look", body)
 		}
 		if strings.Contains(body, "3 lanes need a look") {
 			t.Errorf("sidecar-down fault must not count lanes, got 3:\n%s", body)
 		}
 	})
 	t.Run("adapter-broken is a fault over half no_chapter", func(t *testing.T) {
 		st, dsn := newTestStoreURL(t)
 		db, err := sql.Open("pgx", dsn)
 		if err != nil {
 			t.Fatalf("open %s: %v", dsn, err)
 		}
 		defer db.Close()
 		router := newRouter(st, testConfig())
 		// Four series of the same site; three hold an old no_chapter row (>12h).
 		now := time.Now()
 		old := now.Add(-13 * time.Hour).UnixMilli()
 		for i := 1; i <= 4; i++ {
 			key := fmt.Sprintf("asura:a%d", i)
 			url := fmt.Sprintf("https://asurascans.com/comics/a%d", i)
 			seedSeriesRow(t, st, db, seriesRowSeed{key: key, url: url, cover: "aaa", checkedAt: now.UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 		}
 		for i := 1; i <= 3; i++ {
 			if err := st.RecordSeriesFailure("asura", fmt.Sprintf("a%d", i), "no_chapter", old); err != nil {
 				t.Fatalf("seed no_chapter failure: %v", err)
 			}
 		}
 		seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), Due: 1, Checked: 1})
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "1 lane needs a look") {
 			t.Errorf("adapter-broken fault verdict missing:\n%s", body)
 		}
 	})
 	t.Run("healthy when no fault holds", func(t *testing.T) {
 		router, st := newWebTestServer(t, testConfig())
 		now := time.Now()
 		seedPass(t, st, store.LanePass{Site: "asura", RanAt: now.UnixMilli(), Due: 1, Checked: 1})
 		seedPass(t, st, store.LanePass{Site: "kagane", RanAt: now.UnixMilli(), Skip: latest.SkipAsleep, Due: 1})
 		body := overviewBody(t, router, st)
 		if !strings.Contains(body, "all lanes healthy") {
 			t.Errorf("healthy verdict missing:\n%s", body)
 		}
 	})
 	t.Run("virgin still draws no figures", func(t *testing.T) {
 		virgin, fresh := newWebTestServer(t, testConfig())
 		body := overviewBody(t, virgin, fresh)
 		if !strings.Contains(body, "no Lane has reported yet") {
 			t.Errorf("virgin verdict missing:\n%s", body)
 		}
 		if strings.Contains(body, "all lanes healthy") || strings.Contains(body, "series waiting") {
 			t.Errorf("virgin verdict draws confident zeroes:\n%s", body)
 		}
 	})
 }
 // The Overview never refreshes itself: the Lane rest is an hour, so a timer
 // would re-run a cross-Series join to redraw identical rows. Only the Lanes
 // block carries a refresh attribute.
@@ -3282,120 +2994,6 @@ func TestOverviewZeroIsAnUnlinkedDigit(t *testing.T) {
 	}
 }
 // The finished figure and the site-completed hint ride last in the Hygiene
 // block: seriesFilterOrder appends the pair at the tail, the block renders
 // order[1:], and each count comes from the same aggregate the select is
 // numbered from. Asserting on the body order catches a render that merely
 // shows a figure somewhere.
 func TestOverviewFinishedFigureRidesLast(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:healthy", url: "https://asurascans.com/comics/healthy", cover: "aaa", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(10), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:retired", url: "https://asurascans.com/comics/retired", cover: "bbb", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	if err := st.SetSeriesFinished("asura", "retired", time.Now().UnixMilli()); err != nil {
 		t.Fatalf("finish asura:retired: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	body := overviewBody(t, srv, st)
 	stat := regexp.MustCompile(`<div class="stat"><span class="lbl">(.*?)</span>(?:<a class="fig"[^>]*>(\d+)</a>|<span class="fig zero">(\d+)</span>)</div>`)
 	var labels []string
 	for _, m := range stat.FindAllStringSubmatch(body, -1) {
 		switch m[1] {
 		case "Series", "Manga", "Novels", "Readers":
 			continue // the Library block, not the hygiene figures
 		}
 		labels = append(labels, m[1])
 	}
 	if len(labels) != 11 {
 		t.Fatalf("hygiene block renders %d figures, want 11 (nine problems + finished + site completed):\n%s", len(labels), body)
 	}
 	if labels[len(labels)-2] != "Finished" || labels[len(labels)-1] != "Site says completed" {
 		t.Errorf("the informational tail does not ride last; hygiene order = %v:\n%s", labels, body)
 	}
 	if !strings.Contains(body, `href="/admin/series?filter=finished">1</a>`) {
 		t.Errorf("the finished figure lacks its count and door:\n%s", body)
 	}
 }
 // The site-completed figure is a door into the list that counts it, and the
 // figure agrees with the list's own heading: both come from the same
 // aggregate, so they cannot drift apart.
 func TestOverviewSiteCompletedFigureAgreesWithListHeading(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	hinted := time.Now().Add(-72 * time.Hour).UnixMilli()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:hinted", url: "https://asurascans.com/comics/hinted", cover: "aaa", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(10), bookmarks: 1, siteCompletedAt: hinted})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:plain", url: "https://asurascans.com/comics/plain", cover: "bbb", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	srv := newRouter(st, testConfig())
 	body := overviewBody(t, srv, st)
 	fig := regexp.MustCompile(`href="/admin/series\?filter=site_completed">(\d+)</a>`).FindStringSubmatch(body)
 	if fig == nil {
 		t.Fatalf("overview has no site-completed figure:\n%s", body)
 	}
 	list := adminSeriesPage(t, srv, st, "?filter=site_completed")
 	heading := regexp.MustCompile(`(\d+) series <span`).FindStringSubmatch(list)
 	if heading == nil {
 		t.Fatalf("site-completed list has no heading count:\n%s", list)
 	}
 	if fig[1] != heading[1] {
 		t.Errorf("the overview says %s, the list it links to says %s", fig[1], heading[1])
 	}
 }
 // A measured zero site-completed count stays on the page as a muted digit,
 // never a link: following it would land on an empty list, exactly like every
 // other zero figure.
 func TestOverviewSiteCompletedZeroIsAnUnlinkedDigit(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:one", url: "https://asurascans.com/comics/one", cover: "aaa", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	srv := newRouter(st, testConfig())
 	body := overviewBody(t, srv, st)
 	if !strings.Contains(body, `Site says completed</span><span class="fig zero">0</span>`) {
 		t.Errorf("a zero site-completed figure does not render as a muted digit:\n%s", body)
 	}
 	if strings.Contains(body, `href="/admin/series?filter=site_completed"`) {
 		t.Errorf("a zero site-completed figure is still a link:\n%s", body)
 	}
 }
 // A measured zero finished count stays on the page as a muted digit, never a
 // link: following it would land on an empty list, exactly like every other
 // zero figure.
 func TestOverviewFinishedZeroIsAnUnlinkedDigit(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:one", url: "https://asurascans.com/comics/one", cover: "aaa", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	srv := newRouter(st, testConfig())
 	body := overviewBody(t, srv, st)
 	if !strings.Contains(body, `Finished</span><span class="fig zero">0</span>`) {
 		t.Errorf("a zero finished figure does not render as a muted digit:\n%s", body)
 	}
 	if strings.Contains(body, `href="/admin/series?filter=finished"`) {
 		t.Errorf("a zero finished figure is still a link:\n%s", body)
 	}
 }
 // The waiting figure sums Due over the latest pass per Site — older passes
 // for the same Site must not double-count, so the verdict reads the same
 // latest-per-Site projection the Lanes page reads.
@@ -3832,257 +3430,6 @@ func TestAdminSeriesDetailCorrectionMarker(t *testing.T) {
 	}
 }
 // The finish control lives on the Series detail page only: a neighbouring
 // Finish in the fifty-row grid is not a harmless read the way Check now is,
 // so the list row renders the state as a mark and offers no control to set
 // it. On the detail page the press is confirm-gated — the opener does not
 // post and the only finish POST sits inside the confirm row, targeting the
 // meta fragment it will swap (#158).
 func TestAdminSeriesDetailFinishControl(t *testing.T) {
 	router, st := newWebTestServer(t, testConfig())
 	seed(t, st, store.Bookmark{
 		Key: "asura:solo", Site: "asura", SeriesID: "solo",
 		Title: "Solo", Kind: store.KindManga,
 	})
 	body := seriesDetailPage(t, router, st, "asura:solo")
 	for _, want := range []string{
 		`id="confirm-finish"`,
 		"Mark this Series finished?",
 		`hx-post="/admin/series/asura:solo/finish"`,
 		`hx-target="#detail-meta"`,
 	} {
 		if !strings.Contains(body, want) {
 			t.Errorf("detail page lacks %q:\n%s", want, body)
 		}
 	}
 	// The press travels through the confirm row: the page's only finish POST
 	// sits after the row's id (inside the row), and the opener that reveals
 	// it posts nothing.
 	if opener := strings.Index(body, `id="confirm-finish"`); opener < 0 ||
 		strings.Index(body, `hx-post="/admin/series/asura:solo/finish"`) < opener {
 		t.Errorf("finish POST is not inside the confirm row:\n%s", body)
 	}
 	if strings.Count(body, `hx-post="/admin/series/asura:solo/finish"`) != 1 {
 		t.Errorf("finish POST count = %d, want exactly one (the affirmative):\n%s",
 			strings.Count(body, `hx-post="/admin/series/asura:solo/finish"`), body)
 	}
 	// The list row displays nothing to set: no finish control, no finished
 	// mark on an unfinished Series.
 	list := adminSeriesPage(t, router, st, "")
 	for _, banned := range []string{
 		`/admin/series/asura:solo/finish`,
 		`/admin/series/asura:solo/unfinish`,
 		`mark-faint">finished`,
 	} {
 		if strings.Contains(list, banned) {
 			t.Errorf("list row carries %q:\n%s", banned, list)
 		}
 	}
 }
 // The hint line rides the Finish control: present for a Series the Site
 // marked completed, with its age, absent while the Site has said nothing
 // (zero stamp) and gone once the owner finishes — the Site's stamp keeps
 // standing after retirement, so the hint is suppressed by the same
 // finished_at guard the clock-driven filters carry (issue #170).
 func TestAdminSeriesDetailSiteCompletedHint(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	hinted := time.Now().Add(-72 * time.Hour).UnixMilli()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:hinted", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1, siteCompletedAt: hinted})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:plain", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:retired", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1, siteCompletedAt: hinted})
 	if err := st.SetSeriesFinished("asura", "retired", time.Now().UnixMilli()); err != nil {
 		t.Fatalf("finish asura:retired: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	body := seriesDetailPage(t, srv, st, "asura:hinted")
 	if !strings.Contains(body, "the site says this work is completed (since 3d ago)") {
 		t.Errorf("hinted Series lacks the hint with its age:\n%s", body)
 	}
 	// The hint sits between the Finish opener and the confirm row — a line
 	// beside the control, not the control itself.
 	opener := strings.Index(body, "document.getElementById('confirm-finish').hidden = false")
 	hintAt := strings.Index(body, "the site says this work is completed")
 	confirmAt := strings.Index(body, `id="confirm-finish"`)
 	if opener < 0 || hintAt < 0 || confirmAt < 0 || hintAt < opener || confirmAt < hintAt {
 		t.Errorf("the hint is not a line beside the Finish control (opener %d, hint %d, row %d):\n%s", opener, hintAt, confirmAt, body)
 	}
 	if strings.Contains(seriesDetailPage(t, srv, st, "asura:plain"), "the site says this work is completed") {
 		t.Errorf("an unmarked Series renders the hint:\n%s", body)
 	}
 	if strings.Contains(seriesDetailPage(t, srv, st, "asura:retired"), "the site says this work is completed") {
 		t.Errorf("a finished Series renders the hint:\n%s", body)
 	}
 }
 // The hint is a line of text, never a control: with and without a hint, the
 // Finish control's markup is byte-identical (AC4). Two stores seed the same
 // key so the hx-post URLs match byte for byte; only the hint line differs,
 // and it sits outside the confirm row.
 func TestAdminSeriesDetailFinishControlUnchangedWithHint(t *testing.T) {
 	hinted := time.Now().Add(-72 * time.Hour).UnixMilli()
 	var bodies [2]string
 	for i, sc := range []int64{hinted, 0} {
 		st, dsn := newTestStoreURL(t)
 		db, err := sql.Open("pgx", dsn)
 		if err != nil {
 			t.Fatalf("open %s: %v", dsn, err)
 		}
 		seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:solo", url: "u", cover: "c", checkedAt: time.Now().UnixMilli(), latestNum: floatPtr(1), bookmarks: 1, siteCompletedAt: sc})
 		db.Close()
 		srv := newRouter(st, testConfig())
 		bodies[i] = seriesDetailPage(t, srv, st, "asura:solo")
 	}
 	withHint, without := bodies[0], bodies[1]
 	if !strings.Contains(withHint, "the site says this work is completed") {
 		t.Fatalf("the hinted store did not render a hint:\n%s", withHint)
 	}
 	if strings.Contains(without, "the site says this work is completed") {
 		t.Fatalf("the plain store rendered a hint:\n%s", without)
 	}
 	if got, want := confirmRowMarkup(t, withHint), confirmRowMarkup(t, without); got != want {
 		t.Errorf("the Finish control's markup changed with a hint present:\nwith hint: %s\nwithout:  %s", got, want)
 	}
 }
 // confirmRowMarkup returns the confirm-finish row's HTML, byte for byte —
 // the Finish control AC4 says must not change with a hint present. The row
 // is the outer div (the span plus the inner button pair), with no nested
 // divs beyond that, so the first two </div> closes end it.
 func confirmRowMarkup(t *testing.T, body string) string {
 	t.Helper()
 	start := strings.Index(body, `<div class="confirm-row calm" id="confirm-finish"`)
 	if start < 0 {
 		t.Fatalf("no confirm-finish row in:\n%s", body)
 	}
 	open := strings.Index(body[start:], ">") + start + 1
 	inner := strings.Index(body[open:], "</div>")
 	outer := strings.Index(body[open+inner+len("</div>"):], "</div>")
 	end := open + inner + len("</div>") + outer + len("</div>")
 	return body[start:end]
 }
 // The finish route is the owner's one writer: a finish press stamps
 // finished_at and answers with the swapped detail-meta fragment carrying the
 // "finished <age> ago" mark, and an un-finish press writes zero and answers
 // with a fragment that has no finished line. A malformed key is a 400 and an
 // unknown one a 404, like the other Series mutations (#158).
 func TestSeriesFinishRoute(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:solo", url: "u", checkedAt: 9000, bookmarks: 1})
 	router := newRouter(st, testConfig())
 	cookie := sessionCookie(t, st)
 	for path, want := range map[string]int{
 		"/admin/series/solo/finish":    http.StatusBadRequest,
 		"/admin/series/ghost:x/finish": http.StatusNotFound,
 	} {
 		req := httptest.NewRequest(http.MethodPost, path, strings.NewReader(""))
 		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 		req.AddCookie(cookie)
 		rr := httptest.NewRecorder()
 		router.ServeHTTP(rr, req)
 		if rr.Code != want {
 			t.Errorf("POST %s: status = %d, want %d", path, rr.Code, want)
 		}
 	}
 	// A finish press stamps and answers with the swapped meta fragment whose
 	// mark reads "finished just now".
 	req := httptest.NewRequest(http.MethodPost, "/admin/series/asura:solo/finish", strings.NewReader(""))
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	req.AddCookie(cookie)
 	rr := httptest.NewRecorder()
 	router.ServeHTTP(rr, req)
 	if rr.Code != http.StatusOK {
 		t.Fatalf("POST finish status = %d, want 200 (body %s)", rr.Code, rr.Body.String())
 	}
 	body := rr.Body.String()
 	if !strings.Contains(body, `id="detail-meta"`) {
 		t.Errorf("finish answer is not the meta fragment:\n%s", body)
 	}
 	if !strings.Contains(body, `<span class="mark">finished `) {
 		t.Errorf("finish answer lacks the fresh finished mark:\n%s", body)
 	}
 	var at int64
 	if err := db.QueryRow(`SELECT finished_at FROM series WHERE site = 'asura' AND series_id = 'solo'`).Scan(&at); err != nil {
 		t.Fatalf("read finished_at: %v", err)
 	}
 	if at == 0 {
 		t.Error("finished_at = 0, want the finish stamp written")
 	}
 	// The page after the press offers the instant reversal, no confirm.
 	body = seriesDetailPage(t, router, st, "asura:solo")
 	if !strings.Contains(body, `hx-post="/admin/series/asura:solo/unfinish"`) {
 		t.Errorf("finished detail page lacks the un-finish control:\n%s", body)
 	}
 	if strings.Contains(body, "Mark this Series finished?") {
 		t.Errorf("finished detail page still carries the confirm row:\n%s", body)
 	}
 	// An un-finish press fires instantly and writes zero.
 	req = httptest.NewRequest(http.MethodPost, "/admin/series/asura:solo/unfinish", strings.NewReader(""))
 	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
 	req.AddCookie(cookie)
 	rr = httptest.NewRecorder()
 	router.ServeHTTP(rr, req)
 	if rr.Code != http.StatusOK {
 		t.Fatalf("POST unfinish status = %d, want 200 (body %s)", rr.Code, rr.Body.String())
 	}
 	body = rr.Body.String()
 	if !strings.Contains(body, `id="detail-meta"`) {
 		t.Errorf("unfinish answer is not the meta fragment:\n%s", body)
 	}
 	if strings.Contains(body, `<span class="mark">finished `) {
 		t.Errorf("unfinish answer still carries the finished mark:\n%s", body)
 	}
 	if err := db.QueryRow(`SELECT finished_at FROM series WHERE site = 'asura' AND series_id = 'solo'`).Scan(&at); err != nil {
 		t.Fatalf("read finished_at after un-finish: %v", err)
 	}
 	if at != 0 {
 		t.Errorf("finished_at = %d after un-finish, want 0", at)
 	}
 }
 // A finished Series shows its state in the list row as a faint mark, and the
 // row offers no control to set or clear it — the reversal lives on the
 // detail page, its press, and the mark is the whole of the row's share
 // (#158).
 func TestAdminSeriesListShowsFinished(t *testing.T) {
 	router, st := newWebTestServer(t, testConfig())
 	seed(t, st, store.Bookmark{
 		Key: "asura:solo", Site: "asura", SeriesID: "solo",
 		Title: "Solo", Kind: store.KindManga,
 	})
 	if err := st.SetSeriesFinished("asura", "solo", time.Now().Add(-2*time.Minute).UnixMilli()); err != nil {
 		t.Fatalf("SetSeriesFinished: %v", err)
 	}
 	body := adminSeriesPage(t, router, st, "")
 	if !strings.Contains(body, `<span class="mark mark-faint">finished</span>`) {
 		t.Errorf("list row lacks the finished mark:\n%s", body)
 	}
 	for _, banned := range []string{"solo/finish", "solo/unfinish"} {
 		if strings.Contains(body, banned) {
 			t.Errorf("list row offers %q:\n%s", banned, body)
 		}
 	}
 }
 // The series URL repair validates with the poller's own fetch gate and
 // answers 400 before anything reaches the store; a URL that passes the gate
 // is stored where an Upsert would have ignored it. The request performs no
@@ -4431,49 +3778,3 @@ func TestRemoveRejectsBadKeysAndCapsBody(t *testing.T) {
 		t.Errorf("an oversized body still removed the row:\n%s", list)
 	}
 }
 // The failing pair render in the stats block from the same aggregate the
 // select is numbered from: failing over 12h counts every Series with a
 // failure row older than the cutoff, unverified the Reader-attributed
 // subset, and a measured zero stays a muted digit — never a door.
 func TestOverviewFailingAndUnverifiedFigures(t *testing.T) {
 	st, dsn := newTestStoreURL(t)
 	db, err := sql.Open("pgx", dsn)
 	if err != nil {
 		t.Fatalf("open %s: %v", dsn, err)
 	}
 	defer db.Close()
 	now := time.Now().UnixMilli()
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:broken", url: "u", cover: "c", checkedAt: now, latestNum: floatPtr(1), bookmarks: 1})
 	seedSeriesRow(t, st, db, seriesRowSeed{key: "asura:reader", url: "u", cover: "c", checkedAt: now, latestNum: floatPtr(2), bookmarks: 1, raisedBy: true})
 	if err := st.RecordSeriesFailure("asura", "broken", "not_found", now-24*3600*1000); err != nil {
 		t.Fatalf("seed failure row on broken: %v", err)
 	}
 	if err := st.RecordSeriesFailure("asura", "reader", "not_found", now-24*3600*1000); err != nil {
 		t.Fatalf("seed failure row on reader: %v", err)
 	}
 	srv := newRouter(st, testConfig())
 	body := overviewBody(t, srv, st)
 	if !strings.Contains(body, `href="/admin/series?filter=failing">2</a>`) {
 		t.Errorf("the failing figure lacks its count and door:\n%s", body)
 	}
 	if !strings.Contains(body, `href="/admin/series?filter=unverified">1</a>`) {
 		t.Errorf("the unverified figure lacks its count and door:\n%s", body)
 	}
 	empty, emptySt := newWebTestServer(t, testConfig())
 	body = overviewBody(t, empty, emptySt)
 	if !strings.Contains(body, `Failing over 12h</span><span class="fig zero">0</span>`) {
 		t.Errorf("a zero failing figure does not render as a muted digit:\n%s", body)
 	}
 	if !strings.Contains(body, `Unverified Reader number</span><span class="fig zero">0</span>`) {
 		t.Errorf("a zero unverified figure does not render as a muted digit:\n%s", body)
 	}
 	if strings.Contains(body, `href="/admin/series?filter=failing"`) {
 		t.Errorf("a zero failing figure is still a link:\n%s", body)
 	}
 	if strings.Contains(body, `href="/admin/series?filter=unverified"`) {
 		t.Errorf("a zero unverified figure is still a link:\n%s", body)
 	}
 }
@@ -75,11 +75,7 @@ services:
      # Host header is an IP address or "localhost" — confirmed 2026-08-03,
      # independent of chromedp's own dial logic. The same trap that used to
      # force a pinned Docker IP now forbids the tailnet name.
-      # Owner-notice webhook (issue #171). Empty default, never a
+      BROWSER_WS_URL: ${BROWSER_WS_URL:-}
      # required-guard: unset means the whole path is off, so a local stack
      # runs exactly as it does today. An env var not listed here never
      # reaches the container.
      DISCORD_WEBHOOK_URL: ${DISCORD_WEBHOOK_URL:-}
    depends_on:
      # The migration runner is the first thing the binary does, so a Postgres
      # that is still initialising means a crash-loop until it is not.
@@ -1,109 +0,0 @@
 # ADR-0015: Finished is a fact about the Series, not a bookmark bucket
 Date: 2026-08-22
 Status: accepted
 ## Decision
 "Finished" moves from the per-Reader `bookmarks.status` bucket to a
 Series-owned flag: `series.finished_at`, unix ms, zero while the Series is
 still running. The Lane's gate reads the flag — a Series is polled only while
 `finished_at = 0` — and `bookmarks.status` keeps exactly two values,
 `reading` and `archived`.
 The cutover is one-way, done by migration 0016 in three load-bearing
 statements:
 1. `ALTER TABLE series ADD COLUMN finished_at bigint NOT NULL DEFAULT 0`.
 2. Seed it from the bookmarks: a Series is stamped finished when no bookmark
   on it is outside the `finished` bucket. This mirrors the pre-cutover due
   gate exactly — the old query skipped a Series only while
   `COUNT(*) FILTER (WHERE status <> 'finished') = 0` — so no Series changes
   polling state at the cutover.
 3. Rewrite every `finished` bookmark to `archived`. The bucket is gone; the
   seed ran first because it is the only statement that can still read it.
 The JSON API rejects a `finished` status with the same plain 400 as any
 unknown value, and the web UI no longer offers a Finished tab, a finish
 button, or a finished state badge.
 ## Why a future reader will find this surprising
 The bucket looked Reader-shaped but described a Series fact. A Series is
 finished once, and every Reader reading it is then on a finished Series —
 yet the bucket carried three copies of the answer, one per Reader, free to
 disagree. The disagreement is not theoretical: a second Reader who merely
 kept the Series (or never read it) kept it in `reading`, so the poll gate
 kept fetching a Series the first Reader had closed out, forever. Worse, the
 disagreement was never resolvable — nothing in the system could say "this
 Series is finished" without rewriting every bookmark, which silently edits
 another Reader's progress state.
 The flag is also the only memory of the bucket after the flip. `finished`
 bookmarks become `archived` because a two-value status needs no third
 value, and an archived row must keep meaning "shelved, but the Series is
 being watched" — which is what the row says. The migration's seed is what
 keeps the legacy meaning: a Series every Reader finished is stamped, so the
 Lane stops polling it just as it would have pre-cutover; a Series any
 Reader still reads is left alone, exactly as the old gate left it. A
 Series whose every Reader only shelved (archived) continues to be polled,
 because an archived bookmark is *supposed* to be polled — the cutover
 changes the answer, it does not invent it. And because the flag is a series
 fact, the cutover also repairs the disagreement case: the moment one Reader
 has the Series open, it reads as finished to everyone.
 The migration is the only writer of the flag today; the undo is writing 0,
 which returns the Series to the poll. An owner-facing "mark finished" write
 is deliberately not part of this change — the gate is what this ticket
 rewrites, and the write can land on top of it without touching anything
 here.
 The userscript merge ranks `archived > reading` now. `finished` is not a
 value the wire can carry, so the merge cannot un-finish a row — it cannot
 even name the state it is protecting.
 ## Considered options
 **Keep the bucket and add the flag alongside it, both live.**
 Rejected: two sources of truth for one fact, with the Lane forced to
 resolve "any Reader finished?" on every due query and every Reader write
 still able to resurrect a finished Series. The whole point of the change is
 that the finished state survives Readers.
 **Stamp a Series finished when every bookmark is finished *or* archived.**
 Rejected: it flips polling state at the cutover. Shelved-only Series were
 polled before; making them finished stops the checks the reader knowingly
 asked to keep.
 **Finish as "no bookmark is reading", leaving the buckets untouched.**
 Rejected for the same reason plus one: `archived` is a Reader's own state
 and the flip is what makes the flag the *only* source of finished. Keeping
 the `finished` value in the table would force every status validation,
 merge and UI branch to keep handling a value no write can produce.
 ## Consequences
 - `bookmarks.status` is validated to `reading | archived`, empty meaning
  "keep the stored value"; the API's 400 for `finished` is now the generic
  invalid-status rejection rather than a special case, and the web UI's own
  status control rejects it the same way.
 - The Lane due query and the eligible count read `finished_at`; a Forced
  Poll (issue #146) still overrides the flag — the owner asked, so the Lane
  looks — and the pending force clears itself when the pass stamps the
  check timestamp, never by touching `finished_at`.
 - The web UI has no Finished tab; finished Series render in Archived with
  their archived badge, dimmed like any shelved row.
 - Migration 0016 stamps `finished_at` with the migration's own clock
  (`now()` ms), which is also the undo: write 0 and the Series returns to
  the poll.
 ## Cost of reversing
 The finished buckets are destroyed by the flip; reversing means re-deriving
 per-Reader finished state from a Series fact that now encodes the
 majority-agreement snapshot plus whatever the owner reset since. The stamp
 differentiates "finished at the cutover and untouched" from "finished
 later", but not which Reader's choice each Series carried, and any Series
 the owner has since restored is gone from the derivation entirely. The ADR
 is a statement of intent to ship the one-way cutover and live with its
 consequences; the per-Reader history is not kept anywhere in the schema.
@@ -1,147 +0,0 @@
 # ADR-0016: The failure row is the state
 Date: 2026-08-22
 Status: accepted
 ## Decision
 A Series that used to work and has stopped is recorded in one table,
 `poll_failures`, keyed by the same `(site, series_id)` composite the rest of
 the system uses. One row per failing Series, carrying the outcome word and a
 `failing_since` stamp. The row's **existence** is the failure state: there is
 no success sentinel, no counter, no history, and nothing added to the Series
 row. A correct read deletes the row, and a repeated identical failure writes
 nothing — the stamp ages the run of failures, not the current word.
 The write is one upsert, from the poll pass loop:
 ```sql
 INSERT INTO poll_failures (site, series_id, outcome, failing_since)
 VALUES ($1, $2, $3, $4)
 ON CONFLICT (site, series_id) DO UPDATE SET outcome = EXCLUDED.outcome
 WHERE poll_failures.outcome <> EXCLUDED.outcome
 ```
 `failing_since` is simply absent from the `SET` arm, so it is never
 overwritten, and the `WHERE` makes an unchanged word write nothing at all —
 one statement, no read-then-write race. The clear is a plain `DELETE`; a row
 that is not there is not an error, because the poller clears on every
 successful read and most clears find nothing. The composite foreign key
 cascades: deleting a Series takes its failure row, so orphan removal stays a
 single statement.
 ## Why a future reader will find this surprising
 The failure state lives in a table of its own, not on the Series row and not
 in the pass log. A flag on `series` would be the familiar shape, and the
 pass log already records outcomes per pass — why a third place?
 Because the failure must outlive the pass that observed it and mean
 something the pass row cannot say. The pass log is a per-Lane stream: it
 records that a Site returned N `errors` and M `not_found` on a given run,
 but "this exact Series has been failing for three months" is not a question
 any single pass row answers — it is a question across rows, and the Lanes
 page is a live view of the last 14 days, not a Series index. A Series-level
 fact needs Series-level storage, and a flag on the Series row is the wrong
 shape too: the failure is *transient by definition* (a correct read ends it)
 and *repeatable* (the same Series can fail again next year), so the honest
 record of "failing since" is a stamp that moves, not a column that flips.
 A row that is created and deleted by the read's outcome is that stamp, and
 nothing else: the moment a read succeeds the row is gone, so "is this Series
 failing?" is answered by one indexed existence check — no success sentinel
 to keep consistent with the failure, no counter to reset, no history to
 prune. The state cannot drift out of step with the reads that maintain it,
 because the reads *are* the maintenance.
 The two no-write outcomes are the second surprise. `refused` (the Site is
 holding a challenge) and `unreachable` (the browser sidecar was lost
 mid-loop) issue **no statement at all** — neither an upsert nor a delete.
 The direction matters, and both directions are wrong to touch:
 - **Writing would condemn a whole library for one Site's bad day.** A
  refusal is the Site's mood, not a fact about any particular Series: when
  Cloudflare turns a zone's JS detection on, every Series on that Site reads
  refused in the same pass. Writing those rows would stamp every Series in
  the library as failing on the evidence of one Site's configuration, and
  #166's worklist would present a Site-wide outage as thousands of broken
  Series.
 - **Deleting would claim a recovery nothing read.** A lost sidecar tells us
  nothing about the page — the read never happened. Deleting the row would
  report the Series healthy, and worse, it would reset `failing_since`: the
  age that makes a three-month failure findable would start over on a
  browser restart, erasing evidence no page read contradicted.
 So a refusal or an unreachable pass leaves the table exactly as it found
 it — the pass neither adds rows that would condemn nor deletes rows that
 would claim recovery. The four outcomes that are real evidence about the
 page (`not_found`, `no_chapter`, `unfetchable`, `errors`) write; the two
 that are not write nothing; success deletes. There is no third case.
 ## Considered options
 **A `failing_since` column on the Series row, alongside the failure word.**
 Rejected: it is two more columns on a table every due query and every
 bookmark join already touches, for a state that is transient and repeatable.
 The column would need its own "clear on success" writer anyway — the same
 maintenance the row has — while permanently widening the hottest table in
 the system for a value that is usually absent. And the worklist's join
 would have to distinguish "never failed" from "currently healthy", which
 is exactly the sentinel problem the row avoids: an empty column means both.
 **A counter or last-outcome timestamp instead of (or beside) the row.**
 Rejected: nothing in the system consumes a failure *count* or a
 last-outcome time — the worklist needs "failing and since when". A counter
 invites "three failures = something" thresholds that the ticket explicitly
 keeps out of scope, and a last-outcome timestamp conflates "the word
 changed" with "the run restarted", which the age is deliberately defined
 against. The stamp is the only number that means anything, and the row
 carries exactly that.
 **Write into `poll_passes` and derive the failure state from the pass
 stream.**
 Rejected: a pass row is per-Lane and per-run; deriving "this Series is
 failing since" means scanning 14 days of outcome counts per Series and
 guessing at continuity across retention boundaries. The pass log answers
 "what did this Site's lane do recently"; the failure table answers "which
 Series are broken right now". Two questions, two tables — the pass log is
 already pruned on a fixed cutoff, which would silently reset every
 failure's age the moment the evidence aged out.
 **Refused/unreachable write nothing, but the delete happens anyway (or the
 upsert happens, with no delete).**
 Rejected in both directions, above: writing condemns a library for one
 Site's mood; deleting claims a recovery nothing read and resets the age
 that makes a long failure findable. The asymmetry is the point — the two
 outcomes are evidence about the *environment*, never about a page.
 ## Consequences
 - The poller writes from the pass loop, one call after `checkOne`, and
  clears through the ordinary success path: a Forced Poll that reads the
  page deletes the row with no forced branch of its own, and a Forced Poll
  *request* — which only stamps the request — clears nothing.
 - `poll_failures` is a poll-write table like `poll_lanes` and
  `poll_passes`: the store's two methods live next to the Lane-pass
  writers, and neither runs on a request path. A store failure is logged
  and the poll continues — a failure row is best-effort, and no single bad
  Series may stall a Lane.
 - The due query does not join the table. A failing Series is polled at the
  same pace as any other, because the moment the query started pacing by
  failure state, the age would stop meaning what the worklist reads it as.
 - Orphan removal stays a single statement: the composite foreign key's
  `ON DELETE CASCADE` is what takes the failure row with the Series.
 - The table starts empty at deploy, so nothing is findable for the first
  twelve hours after deploy and a pre-existing breakage reads as new.
  Accepted; the alternative is inventing history.
 ## Cost of reversing
 The failure state is derived, not stored: a rollback drops the table and
 every in-progress failure age with it, leaving the pass log's outcome
 counts as the only trace — which is exactly the "log line nobody reads"
 the ticket set out to replace. Recreating the table later starts the ages
 over, so a reversal that is later reversed loses the evidence of the
 intervening failures. The failure state itself, however, is the one thing
 that is *not* lost by reversing: it is re-derived from the next pass, in
 the same direction the original design derives it — the row is
 recreated by the next failing read and deleted by the next good one.
@@ -2,7 +2,7 @@
 Source of truth: the Claude Design project **BookmarkManager Web UI**
 (`969ac210-fe02-4c01-ae1b-9a271dcc779a`, `index.html` + siblings
-`archived.html`/`fav.html`/`new.html`/`login.html`/`mobile.html`,
+`archived.html`/`fav.html`/`finished.html`/`new.html`/`login.html`/`mobile.html`,
 `style.css`, `filter.js`). This file records the rules that got implemented so
 a future agent can extend the UI without re-reading the design.
@@ -48,7 +48,7 @@ Defined once in `backend/internal/web/static/style.css` `:root`, mirrored in the
 | --- | --- | --- | --- |
 | `--ink` | `#100f0e` | `#f7f4ef` | page |
 | `--ash` | `#161413` | `#efeae3` | recessed panel (chapter form) |
-| `--dim` | `#0d0c0b` | `#f1ede7` | archived row background |
+| `--dim` | `#0d0c0b` | `#f1ede7` | archived / finished row background |
 | `--rule` | `#221f1d` | `#e0dad2` | hairline between sheets, button borders |
 | `--rule-soft` | `#1a1817` | `#e8e3dc` | the measure's own side edges |
 | `--field-line` | `#2c2926` | `#d4cdc4` | input borders, ghost-button underline |
@@ -70,7 +70,7 @@ Defined once in `backend/internal/web/static/style.css` `:root`, mirrored in the
 | `--danger-soft` | `#e2aaa1` | `#7c2c22` | text on danger wash |
 | `--brass` | `#b8912f` | `#8a681c` | favourite — a cooler second metal |
 | `--slate` | `#7fa0c0` | `#3f6689` | archive accent |
-| `--moss` | `#7fae86` | `#3d6c46` | finished Series label |
+| `--moss` | `#7fae86` | `#3d6c46` | finished accent |
 | `--clay` | `#b5906f` | `#7c5533` | set-chapter accent |
 | `--trash` | `#977671` | `#8c6558` | remove, at rest — icons need 3:1, not 4.5:1 |
 | `--patina` | `#5fb3a6` | `#1f6f66` | admin page only — a Poll Lane needing attention, a Reader whose reports are blocked |
@@ -164,9 +164,9 @@ rather than scaling the artwork down.
 **Action key** (`.keyrow`): one permanent line under the tabs naming what
 every icon in `.actions` does — Read / Fav / Chapter / Archive / Done /
-Delete — so the icon strip on a card is never a guess. The key follows the
+Delete — so the icon strip on a card is never a guess. The key follows the tab,
-tab, not the row: under Archived, Archive becomes Restore. On a phone each
+not the row: Archive becomes Restore under Archived and Finished, and Finished
-pair stacks icon-over-word
+drops Done. On a phone each pair stacks icon-over-word
 (`flex-direction: column`) so the word gets the full cell width; ≥720px it lays
 out icon-beside-word at the same wording. `.pair.brass` and `.pair.trash`
 carry their icon's resting accent so the key itself teaches the colour
@@ -179,7 +179,7 @@ article.card[.is-new|.is-dim]#card-<key>[data-title]
  .row
    a.cover[tabindex="-1" aria-hidden]   img | span.monogram, + span.foot-rule[.brass]
    .body          .title-line (h3.title + svg.fav-mark) , p.meta
-    .actions       play, favourite, chapter | lifecycle: archive/restore, remove
+    .actions       play, favourite, chapter | lifecycle: archive/restore, finish, remove
  form.chapter-form[hidden]   .hint + .field(input + Save) + .hint (latest known)
  .confirm-row[.calm][hidden]  × one per lifecycle action, span + (go/danger-solid, Cancel)
  p.error-inline[hidden]
@@ -188,7 +188,7 @@ article.card[.is-new|.is-dim]#card-<key>[data-title]
 Rules that are easy to break:
 - `.is-new` only when `Status == reading && HasNewChapter`; `.is-dim` for
-  `archived`. Both are set on the `<article>` — every heat and
+  `archived` and `finished`. Both are set on the `<article>` — every heat and
  dim rule is a descendant selector off those two classes, so a new sub-element
  inherits the state for free.
 - `.actions` is `flex: 1 0 100%` inside `.row`, which is what makes it a
@@ -196,19 +196,19 @@ Rules that are easy to break:
  the row at ≥720px. Cells are 46px tall on phone (thumb target) and divided by
  `border-right: 1px var(--rule)`, last child none.
 - Three clusters by consequence, in this order: navigate (`.play`) | organize
-  (`.fav`, `.pencil`) | lifecycle (`.box`/`.restore`, `.remove`,
+  (`.fav`, `.pencil`) | lifecycle (`.box`/`.restore`, `.finish`, `.remove`,
  each carrying the `.lifecycle` class). Lifecycle cells sit on a recessed
  `--ash` ground so the thumb reads "this one moves the series" before it
  reads which icon it landed on; ≥720px they separate by a 10px gap instead of
  the phone's inset hairline.
 - Every lifecycle button that moves a series out of the list is
-  **confirm-gated**: it opens its own `.confirm-row` (`archive`,
+  **confirm-gated**: it opens its own `.confirm-row` (`archive`, `finish`,
-  `remove` — `toggleConfirmRow(key, kind)` in `filter.js`). Archive asks in
+  `remove` — `toggleConfirmRow(key, kind)` in `filter.js`). Archive and finish
-  `.calm` grey since it's reversible; remove alone gets the
+  ask in `.calm` grey since they're reversible; remove alone gets the
  `--danger-wash` treatment and names the series in its question. Restore
  fires instantly — no confirm — because it's the reversal.
 - Per-action hover/press accent: `.fav` → `--brass`, `.pencil` → `--clay`,
-  `.box` → `--slate`. `.play` stays paper/ember (ember
+  `.box` → `--slate`, `.finish` → `--moss`. `.play` stays paper/ember (ember
  only when `.is-new`). `.remove` stays `--trash` at rest, `--danger` on
  hover. Desktop cell borders follow the same accent on hover
  (`border-color: currentColor`); the two coloured *resting* states
@@ -286,7 +286,7 @@ No transforms on hover, no scale, no easing curves beyond `ease-out`/`linear`.
   never reuse `--ember` or `--danger` for anything but their one meaning.
 3. If it is per-series, hang it off `.is-new` / `.is-dim` rather than adding a
   third state class.
-4. If it removes a series from the current view (archive/remove-shaped),
+4. If it removes a series from the current view (archive/finish/remove-shaped),
   it is confirm-gated via its own `.confirm-row` — no exceptions, restore is
   the only instant action because it's the one that's reversible by nature.
 5. Icon → `templates/icons.html`; nothing inlines SVG paths. Brand mark stays
@@ -471,10 +471,9 @@
  }
  // Only an explicit archive/restore has an opinion about the bucket. Every
-  // other write omits `status`, so the server keeps the stored one —
+  // other write omits `status`, so the server keeps the stored one — otherwise
-  // otherwise a cached value would resend a stale status (the API rejects
+  // a cached value would resend "finished" (which the API rejects with 400) or
-  // unknown values with 400) or silently un-archive a series archived on
+  // silently un-archive a series archived on another device.
  // another device.
  async function apiPut(key, obj, { sendStatus = false } = {}) {
    const body = Object.assign({}, obj);
    if (!sendStatus) delete body.status;
@@ -551,12 +550,6 @@
    return b.kind || "manga";
  }
  // finished is a fact about the Series, decided from the owner's side and
  // derived on the wire (issue #157); the panel only labels it.
  function finishedLabel(b) {
    return b && b.finished ? "Finished" : "";
  }
  // ============================================================
  // Retry queue
  //
@@ -895,8 +888,8 @@
  }
  // Archive parks a series: it leaves All and Favourites but the server keeps
-  // polling it for new chapters. finished is not a bucket the script can
+  // polling it for new chapters. "finished" is deliberately not reachable from
-  // reach — it is a fact about the Series now (issue #157).
+  // here — the API rejects that value, it is a web-UI decision.
  async function toggleArchive(key) {
    const existing = state.byKey[key];
    if (!existing) return;
@@ -973,6 +966,7 @@
    const now = Date.now();
    const due = state.list
      .filter((b) => b.site === site && b.series_url)
      .filter((b) => statusOf(b) !== "finished")
      .filter((b) => now - (checked[b.key] || 0) >= LATEST_CHECK_THROTTLE_MS)
      .sort((a, b) => (checked[a.key] || 0) - (checked[b.key] || 0))
      .slice(0, LATEST_CHECK_BATCH);
@@ -1341,8 +1335,8 @@
    }
    // Tabs narrow what is drawn; state.list always holds every bookmark.
-    // Archived rows are hidden from All and Favourites; a Series that is
+    // Archived rows are hidden from All and Favourites, and finished ones —
-    // finished is the web UI's business and arrives archived (issue #157).
+    // which only the web UI can set — are hidden from every tab.
    for (const [id, tab] of [["tabAll", "all"], ["tabFav", "favorites"], ["tabArc", "archived"]]) {
      root.getElementById(id).classList.toggle("active", activeTab === tab);
    }
@@ -1405,7 +1399,6 @@
      el("div", { class: "meta" }, [
        el("a", { class: "go-t t", href: cont, text: b.title || b.series_id }),
        el("div", { class: "c" + (behind ? " behind" : ""), text: sub }),
        b.finished && el("span", { class: "finished", text: finishedLabel(b) }),
        el("div", { class: "actions" }, [
          el("button", {
            class: "btn small star" + (b.favorite ? " on" : ""),
@@ -1676,7 +1669,7 @@
      --paper: #f2ece5; --paper-hot: #f0d3cb; --paper-dim: #ddd5cb;
      --mute: #8d857c; --mute-2: #5a5450; --faint: #3a3733; --faint-2: #57504b;
      --ember: #e0452c; --ember-wash: #1a1211; --ember-ink: #150907;
-      --ember-soft: #eda798; --brass: #b8912f; --trash: #6b5450; --moss: #7fae86;
+      --ember-soft: #eda798; --brass: #b8912f; --trash: #6b5450;
      --font-display: Georgia, "Times New Roman", serif;
      --font-mono: ui-monospace, SFMono-Regular, Menlo, monospace;
      --font-body: system-ui, -apple-system, sans-serif;
@@ -1795,12 +1788,6 @@
      font: 400 17px/1.2 var(--font-display); color: var(--paper-dim);
      max-width: 100%; white-space: nowrap; overflow: hidden; text-overflow: ellipsis;
    }
    /* finished: a Series fact, not a state class (issue #157) — same meta
       typography as .c, moss instead of mute. */
    .finished {
      margin: 0; color: var(--moss);
      font: 500 10px/1.4 var(--font-mono); letter-spacing: .12em; text-transform: uppercase;
    }
    .item.hot .t { color: var(--paper-hot); border-bottom: 1px solid var(--ember); padding-bottom: 3px; }
    .item.dim .t { font-style: italic; color: var(--mute); }
    .c {
@@ -1851,7 +1838,7 @@
  // Exposes pure logic only — see userscript/test/logic.test.js.
  // ============================================================
  if (typeof window === "undefined" && typeof module === "object" && module.exports) {
-    module.exports = { stripBuildHash, comixSeriesId, asura, demonic, comix, kagane, anchorsFromHTML, statusOf, kindOf, finishedLabel };
+    module.exports = { stripBuildHash, comixSeriesId, asura, demonic, comix, kagane, anchorsFromHTML, statusOf, kindOf };
  }
  // ============================================================
@@ -268,9 +268,8 @@
      // Duplicate case (spec user story 2): one row must survive, and it is
      // the one already under the repaired key — with the stale row's
      // progress carried across when it is ahead, favourite OR'd, and the
-      // stronger lifecycle bucket kept (archived > reading, so a merge can
+      // stronger lifecycle bucket kept (finished > archived > reading, so a
-      // never silently un-archive a row). finished is not a bucket the
+      // merge can never silently un-archive or un-finish a row).
      // script can see (issue #157).
      const merged = Object.assign({}, existing);
      if (
        existing.last_chapter_num == null ||
@@ -281,7 +280,7 @@
        merged.last_chapter_url = stale.last_chapter_url;
      }
      merged.favorite = !!(existing.favorite || stale.favorite);
-      const rank = (s) => ({ archived: 1, reading: 0 }[s || "reading"] || 0);
+      const rank = (s) => ({ finished: 2, archived: 1, reading: 0 }[s || "reading"] || 0);
      merged.status = rank(stale.status) > rank(existing.status) ? stale.status : existing.status;
      merged.updated_at = Math.max(existing.updated_at || 0, stale.updated_at || 0);
      listOut = list.filter((b) => b.key !== oldKey).map((b) => (b.key === newKey ? merged : b));
@@ -406,10 +405,9 @@
  }
  // Only an explicit archive/restore has an opinion about the bucket. Every
-  // other write omits `status`, so the server keeps the stored one —
+  // other write omits `status`, so the server keeps the stored one — otherwise
-  // otherwise a cached value would resend a stale status (the API rejects
+  // a cached value would resend "finished" (which the API rejects with 400) or
-  // unknown values with 400) or silently un-archive a series archived on
+  // silently un-archive a series archived on another device.
  // another device.
  async function apiPut(key, obj, { sendStatus = false } = {}) {
    const body = Object.assign({}, obj);
    if (!sendStatus) delete body.status;
@@ -486,12 +484,6 @@
    return b.kind || "manga";
  }
  // finished is a fact about the Series, decided from the owner's side and
  // derived on the wire (issue #157); the panel only labels it.
  function finishedLabel(b) {
    return b && b.finished ? "Finished" : "";
  }
  // ============================================================
  // Retry queue
  //
@@ -800,8 +792,8 @@
  }
  // Archive parks a series: it leaves All and Favourites but the server keeps
-  // polling it for new chapters. finished is not a bucket the script can
+  // polling it for new chapters. "finished" is deliberately not reachable from
-  // reach — it is a fact about the Series now (issue #157).
+  // here — the API rejects that value, it is a web-UI decision.
  async function toggleArchive(key) {
    const existing = state.byKey[key];
    if (!existing) return;
@@ -886,6 +878,7 @@
    const now = Date.now();
    const due = state.list
      .filter((b) => b.site === site && b.series_url)
      .filter((b) => statusOf(b) !== "finished")
      .filter((b) => now - (checked[b.key] || 0) >= LATEST_CHECK_THROTTLE_MS)
      .sort((a, b) => (checked[a.key] || 0) - (checked[b.key] || 0))
      .slice(0, LATEST_CHECK_BATCH);
@@ -1248,8 +1241,8 @@
    }
    // Tabs narrow what is drawn; state.list always holds every bookmark.
-    // Archived rows are hidden from All and Favourites; a Series that is
+    // Archived rows are hidden from All and Favourites, and finished ones —
-    // finished is the web UI's business and arrives archived (issue #157).
+    // which only the web UI can set — are hidden from every tab.
    for (const [id, tab] of [["tabAll", "all"], ["tabFav", "favorites"], ["tabArc", "archived"]]) {
      root.getElementById(id).classList.toggle("active", activeTab === tab);
    }
@@ -1312,7 +1305,6 @@
      el("div", { class: "meta" }, [
        el("a", { class: "go-t t", href: cont, text: b.title || b.series_id }),
        el("div", { class: "c" + (behind ? " behind" : ""), text: sub }),
        b.finished && el("span", { class: "finished", text: finishedLabel(b) }),
        el("div", { class: "actions" }, [
          el("button", {
            class: "btn small star" + (b.favorite ? " on" : ""),
@@ -1601,7 +1593,7 @@
      --paper: #f2ece5; --paper-hot: #f0d3cb; --paper-dim: #ddd5cb;
      --mute: #8d857c; --mute-2: #5a5450; --faint: #3a3733; --faint-2: #57504b;
      --ember: #e0452c; --ember-wash: #1a1211; --ember-ink: #150907;
-      --ember-soft: #eda798; --brass: #b8912f; --trash: #6b5450; --moss: #7fae86;
+      --ember-soft: #eda798; --brass: #b8912f; --trash: #6b5450;
      --font-display: Georgia, "Times New Roman", serif;
      --font-mono: ui-monospace, SFMono-Regular, Menlo, monospace;
      --font-body: system-ui, -apple-system, sans-serif;
@@ -1727,12 +1719,6 @@
      font: 500 10px/1.4 var(--font-mono); letter-spacing: .12em; text-transform: uppercase;
    }
    .c.behind { color: var(--ember); }
    /* finished: a Series fact, not a state class (issue #157) — same meta
       typography as .c, moss instead of mute. */
    .finished {
      margin: 0; color: var(--moss);
      font: 500 10px/1.4 var(--font-mono); letter-spacing: .12em; text-transform: uppercase;
    }
    .actions { display: flex; gap: 0; flex-wrap: wrap; margin-top: 2px; }
    .btn {
      background: none; color: var(--mute); border: 1px solid var(--rule);
@@ -1776,7 +1762,7 @@
  // Exposes pure logic only — see userscript/test/novel-logic.test.js.
  // ============================================================
  if (typeof window === "undefined" && typeof module === "object" && module.exports) {
-    module.exports = { novelfull, lightnovelworld, anchorsFromHTML, statusOf, kindOf, maxChapter, escapeRe, computeLatestChapter, repairLnwStaleRow, finishedLabel };
+    module.exports = { novelfull, lightnovelworld, anchorsFromHTML, statusOf, kindOf, maxChapter, escapeRe, computeLatestChapter, repairLnwStaleRow };
  }
  // ============================================================
@@ -58,7 +58,6 @@ const {
  anchorsFromHTML,
  statusOf,
  kindOf,
  finishedLabel,
 } = require("../manga-bookmark.user.js");
 // detect() reads only these four properties off location.
@@ -396,18 +395,7 @@ test("statusOf defaults a missing status to reading", () => {
  assert.equal(statusOf({}), "reading");
  assert.equal(statusOf({ status: "" }), "reading");
  assert.equal(statusOf({ status: "archived" }), "archived");
-});
+  assert.equal(statusOf({ status: "finished" }), "finished");
 // ============================================================
 // finishedLabel — finished is a fact about the Series (issue #157), which is
 // the server's business; the panel only names it. The label is text through
 // the el() helper, never markup.
 // ============================================================
 test("finishedLabel names a finished series and nothing else", () => {
  assert.equal(finishedLabel({ finished: true }), "Finished");
  assert.equal(finishedLabel({ finished: false }), "");
  assert.equal(finishedLabel({}), "");
 });
 // ============================================================
@@ -49,7 +49,6 @@ const {
  kindOf,
  maxChapter,
  repairLnwStaleRow,
  finishedLabel,
 } = require("../novel-bookmark.user.js");
 function loc(href) {
@@ -564,23 +563,6 @@ test("repairLnwStaleRow does not regress progress when the repaired-key row is a
  assert.equal(out.list[0].last_chapter_num, 100);
 });
 // ============================================================
 // Merge rank — exactly two values: archived beats reading, and nothing else
 // can ever win (issue #157 retired the finished bucket).
 // ============================================================
 test("repairLnwStaleRow merge keeps archived over reading and lets no third value win", () => {
  const canonical = (over) => staleRow(Object.assign({ key: "lightnovelworld:immortality-simulator" }, over));
  // archived beats reading whether it arrives as the stale row or the repaired one
  let out = repairLnwStaleRow([canonical({ status: "archived" }), staleRow({ status: "reading" })], [], {}, lnwPage());
  assert.equal(out.list[0].status, "archived");
  out = repairLnwStaleRow([staleRow({ status: "archived" }), canonical({ status: "reading" })], [], {}, lnwPage());
  assert.equal(out.list[0].status, "archived");
  // "finished" is not a bucket anymore: a row carrying it reads as the
  // default, so it can never win (issue #157).
  out = repairLnwStaleRow([staleRow({ status: "finished" }), canonical({ status: "reading" })], [], {}, lnwPage());
  assert.equal(out.list[0].status, "reading");
 });
 // ============================================================
 // kindOf
 // ============================================================
@@ -593,18 +575,6 @@ test("kindOf passes through novel", () => {
  assert.equal(kindOf({ kind: "novel" }), "novel");
 });
 // ============================================================
 // finishedLabel — finished is a fact about the Series (issue #157), which is
 // the server's business; the panel only names it. The label is text through
 // the el() helper, never markup.
 // ============================================================
 test("finishedLabel names a finished series and nothing else", () => {
  assert.equal(finishedLabel({ finished: true }), "Finished");
  assert.equal(finishedLabel({ finished: false }), "");
  assert.equal(finishedLabel({}), "");
 });
 // ============================================================
 // Source guard
 //
Author	SHA1	Message	Date
sulthan	f532e50516	Orphan removal: the database is the guard (#155 )	2026-08-22 09:58:11 +07:00
sulthan	bc64a1d894	backend: remove orphan series from the admin (ticket #155 ) (*Store).RemoveSeries deletes one series row by (site, series_id) via a plain parameterized DELETE; a bookmarks_series_fk violation outside 23503 is translated into the ErrSeriesHasBookmarks sentinel so no driver type escapes the store. The caller reads the row's cover address before the delete and reclaims it after: ReclaimCover's guard cannot pass while a series row still points at the address. POST /admin/series/{key}/remove answers the list row with the removed row's fragment plus the heading re-rendered out of band at the fresh count (HX-Reswap: delete removes the row through the same button that swaps the refusal back in), and navigates from the detail page to the No-Readers list (HX-Redirect for htmx, a 303 for plain clients). A removal that races a fresh Bookmark is a refusal, not a 500: the row re-renders at its new count with the fact spelled out. The control renders only at zero Reader count on both surfaces, gated by hx-confirm with the brief's copy.	2026-08-22 09:55:01 +07:00
sulthan	ba2b6eebbb	Latest Chapter provenance: one derived line naming the actor class (#152 )	2026-08-22 09:37:08 +07:00
sulthan	f40894b108	Cover byte reclamation: one guarded helper, file first (#154 )	2026-08-22 09:36:45 +07:00
sulthan	a4ea80dcc2	Cover byte reclamation: one guarded helper, file first, covers row last (#154 )	2026-08-22 09:34:02 +07:00
sulthan	a4491babed	Latest Chapter provenance line naming the actor class (#152 )	2026-08-22 09:32:25 +07:00
sulthan	e1d61534bb	A Forced Poll replaces the Cover; an ordinary pass still only fills a blank one (#153 )	2026-08-22 09:23:59 +07:00
sulthan	ad09569f2e	Series URL repair, owner-typed and gated by the poller's own fetch gate (#151 )	2026-08-22 09:23:59 +07:00
sulthan	35a86f5eb9	Correct the three-outcome comment; keep doc comment attached to storeCover (#153 )	2026-08-22 09:23:18 +07:00
sulthan	424d2c6600	Series URL repair: owner-typed, gated by the poller's own fetch gate (#151 )	2026-08-22 09:21:00 +07:00
sulthan	7e1cbdde9e	Forced Poll replaces the Cover; ordinary pass still fills only a blank one (#153 )	2026-08-22 09:19:15 +07:00
sulthan	448631c78e	Cover addresses derived from the bytes; ReplaceSeriesCover (#150 ) # Conflicts: # backend/internal/store/store_test.go	2026-08-22 09:08:37 +07:00
sulthan	f3b2722568	Latest Chapter correction: one numeric input, owner-gated (#149 )	2026-08-22 09:08:06 +07:00
sulthan	b9fc83217d	#150 : address covers by bytes; ReplaceSeriesCover	2026-08-22 09:05:53 +07:00
sulthan	c9b1f2a334	Latest Chapter correction: one numeric input, owner-gated (#149 )	2026-08-22 09:04:24 +07:00