diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 60b30e2..81a1ffc 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -56,9 +56,10 @@ engine is one module and a few small changes:
    - the domains its CLI needs (`egress`);
    - where the CLI keeps its login (`home`), the variable that points it there (`home_env`), and its own login
      command. An engine that runs on API keys or on a local model server has no login: it implements `Keyed`
-     instead, its `providers` (each with where to create a key and where its models are listed) and `with_key`,
-     which returns the engine on an account's key. The key reaches the step only as a file in `/ctx`
-     (`Invocation.files`), never on the command line or in the environment;
+     instead, its `providers` (each with where to create a key, where its models are listed and, when models.dev
+     has them, its id there, so that the Accounts page suggests its models) and `with_key`, which returns the
+     engine on an account's key. The key reaches the step only as a file in `/ctx` (`Invocation.files`), never on
+     the command line or in the environment;
    - how a step becomes a command line (`invocation`), and how the output becomes events and a result (`parse` and
      `result`).
 2. **If the CLI can read the account's quota without calling the model,** add `quota_invocation` and
@@ -66,8 +67,9 @@ engine is one module and a few small changes:
    engine is `Keyed`: then lastcall's ledger reads what its steps cost, so `result` must report `cost_usd`. A
    window that limits only some models names the model in `Window.model`.
 3. **Register it** in `src/lastcall/engines/__init__.py`.
-4. **Pick its models** for each tier (fast, balanced, deep) in `src/lastcall/data/tiers.json`. An engine on API
-   keys may have none there: each of its accounts names its models.
+4. **Pick its models** for each tier (fast, balanced, deep) in `src/lastcall/data/tiers.json`, and the names that
+   its CLI takes under `models`, which the Accounts page suggests. An engine on API keys may have none there:
+   each of its accounts names its models.
 5. **Install its CLI**, at a pinned version, in `runner/Dockerfile`, and add its login to `runner/login.sh`, or, for
    an engine with no login, a branch that says so. A test checks that every engine has one there.
 6. **Regenerate `egress/filter`.** The command is in `tests/test_egress.py`.
diff --git a/DESIGN.md b/DESIGN.md
index 2a2e7cd..10ae170 100644
--- a/DESIGN.md
+++ b/DESIGN.md
@@ -272,12 +272,12 @@ accounts:
   - id: claude-max
     engine: claude-code
     login: cli                 # official login inside the account's credential volume
-    tiers: {fast: haiku/medium, balanced: sonnet/high, deep: opus/high}
+    tiers: {fast: haiku/medium, balanced: sonnet/high, deep: opus/xhigh}
     spend: {policy: before-reset, reserve_pct: 10}
   - id: chatgpt-plus
     engine: codex
     login: cli
-    tiers: {fast: gpt-6-luna/high, balanced: gpt-6.1-sol/high, deep: gpt-6.1-sol/high}
+    tiers: {fast: gpt-6-luna/medium, balanced: gpt-6.1-sol/high, deep: gpt-6.1-sol/xhigh}
     spend: {policy: before-reset, reserve_pct: 10}
   - id: openrouter             # v0.5
     engine: opencode
@@ -301,6 +301,33 @@ goes back to the default. The data file also lists the effort levels that each e
 `--effort` (low to max), Codex's `model_reasoning_effort` (minimal to max) and OpenCode's `--variant`, whose levels
 depend on the model. More effort finds more, and spends more of the quota or the budget.
 
+The default efforts differ by tier because the work does: `fast` is only asked for by a repository's own reviewers,
+so it takes `medium`; `balanced` runs the reviewers, at `high`; and `deep` runs the judge, the implementers and the
+improvement plans, where quality matters most and lastcall spends quota that would expire anyway, at `xhigh`. Both
+engines' effort lists include `xhigh`.
+
+**Suggested models.** The model fields of that page suggest names with a `<datalist>`: the owner picks one or types
+any other, since the catalogs change every month. Where the names come from depends on the account:
+
+- An account on a CLI login gets the `models` of its engine in the data file, the names that its CLI takes: Claude
+  Code's aliases `haiku`, `sonnet` and `opus`, which mean the newest model of their family on the Anthropic API,
+  and the models that Codex's own catalog lists for choosing and has not replaced with a newer one
+  (`codex debug models --bundled`). `fable` is left out on purpose: `claude -p` can bill a Fable request to usage
+  credits without asking, and lastcall never spends paid usage.
+- An account on an API key (OpenCode on OpenRouter, Anthropic or OpenAI) gets the models of its provider from
+  models.dev's public catalog, `https://models.dev/api.json`, where OpenCode reads its prices too. The id of the
+  provider there is `Provider.catalog`. The web UI asks through the same `fetch` as its other lookups, with a
+  `User-Agent` of its own (models.dev answers 403 to the default one) and gzip (the catalog weighs 6 MB, or 0.6 MB
+  packed), and waits 5 seconds at most. One request answers for every provider, and the answer stays in memory for
+  a day, since the Accounts page asks on every load. A failure is kept for 10 minutes: meanwhile the fields suggest
+  nothing and the page works as before. Of each provider it keeps at most 1000 models, the ones that a step can
+  run on: they call tools, have a price (the budget needs one) and are not deprecated, and their ids are ones that
+  an account may name.
+- The form that adds an API key cannot follow the provider that it has chosen, since the page runs no script: its
+  model fields suggest the models of every provider together (OpenRouter writes the maker first, as in
+  `qwen/qwen3-coder`).
+- A local model server (Ollama) gets no suggestions: the web UI cannot reach it.
+
 **Several accounts on one project.** Different providers find different problems (section 16). A review step can
 therefore fan out across accounts, and one judge merges the results.
 
@@ -461,11 +488,11 @@ multiplies the score.
     read.
 - **Container logs** (`lastcall.logs`), for apps that run in Docker on lastcall's own host, with no change to their
   code. None is read until the owner gives it a project:
-  - The settings page lists the host's containers (`lastcall logs list` in the terminal), and the owner chooses the
-    project of each one to read. lastcall suggests one from the container's image (`ghcr.io/<owner>/<name>`, without
-    its tag), else its Compose project, else its name (`<name>-web-1`), when only one project fits. A suggestion is
-    read only once the owner saves it, and a no to it is remembered, so that it is not suggested again. The choices
-    live in the service's database.
+  - The settings page lists the host's containers (`lastcall logs list` in the terminal; section 13 describes the
+    page), and the owner chooses the project of each one to read. lastcall suggests one from the container's image
+    (`ghcr.io/<owner>/<name>`, without its tag), else its Compose project, else its name (`<name>-web-1`), when only one
+    project fits. A suggestion is read only once the owner chooses it, and a no to it is remembered, so that it is not
+    suggested again. The choices live in the service's database.
   - A container labelled `lastcall.project=<owner/name>` in its compose file is read for that project, matched
     without regard to case, with no choice on the settings page, which shows it with its project: the choice can
     live with the app. The two ways work together, and the label wins over a choice.
@@ -789,10 +816,10 @@ the notice sticks to the top from 48 rem up (when the window is also at least 36
 clear when it scrolls to the card or to a focused control; on a phone it stays in the flow above the cards, so it never
 hides what it brought you to. The settings page holds the connection to an error tracker (Sentry or GlitchTip: the
 address, the organization and a read-only token, saved only when one request with them gets through), the container logs
-(the host's containers, each with its project or the one lastcall suggests, and the label that works as well), the logs
-in Loki (the connection, the label that names the sources, and the project of each, with suggestions), and the
-notifications: the destinations, chosen by service with only the fields that service needs (Telegram finds the owner's
-chat from the bot's recent messages) or as any Apprise URL, saved only when their test notification gets through, kept
+(the host's containers, and the label that works as well), the logs in Loki (the connection, the label that names the
+sources, and the sources), both lists in three parts, which the paragraphs below describe, and the notifications: the
+destinations, chosen by service with only the fields that service needs (Telegram finds the owner's chat from the bot's
+recent messages) or as any Apprise URL, saved only when their test notification gets through, kept
 in the secret store and shown with their secrets hidden; the events (a pull request opens, decisions or ideas wait,
 lastcall merges an approved pull request or proposes a revert, a run fails or stops early, an account has paid usage on
 or its quota cannot be read, and, if the owner wants, a burst starts) and their language. A problem is told once when it
@@ -816,6 +843,38 @@ brings the owner back after the installation starts a reading of the suggestions
 Adding by an address, which asks GitHub whether the App is installed there, stays for a repository that is not in the
 list.
 
+The containers of the settings page and the sources in Loki come in three parts, so that dozens of them stay short
+(`_lists.html` draws both). `Read now` comes first: what lastcall reads, in compact rows. A container with the label
+`lastcall.project` says that its label decides and has nothing to stop; one whose label names no project says so, and is
+read once the project is added. One that the owner chose shows its project, as the Projects page writes it, with a Stop
+reading button, which records the owner's no. The suggested ones, which have no label, no choice and one project that
+fits, use the tiles of the Projects page's add-many form: a checkbox with the container and the project that it would be
+read for, a button that reads all of them, and a bar that reads or skips the ticked ones (a skip records the no, as
+`lastcall logs set <container> -` does, so that the suggestion does not come back). Every other container or source goes
+in a fold that says how many they are, closed unless a filter is set or a typed project is refused. From the seventh on,
+the fold has a filter by name (`logs_q` and `loki_q` in the address, ignoring case, each keeping the other's, and the
+fold opens while one is set), and each of them gets one text field whose `<datalist>` holds the projects, so that the
+page lists the projects once, not once in every row. A choice for a project that was removed shows apart in that fold,
+as before, and no save erases it: an empty field changes nothing. lastcall's own containers, which are in its Compose
+project or are named `lastcall-...`, never show, in either list.
+
+The forms of those parts post to `POST /settings/logs` and `POST /settings/loki/sources` (which also says the label that
+names the sources: the choices belong to it). Each row is `name-N` and, for a project, `project-N`, and `pick` says what
+the button asks: `selected` (the rows ticked in `tick`), `suggested` (all of them), `skip` or `stop` (a no), or, without
+it, the projects typed in the fold of the others. The server asks the host and Loki nothing: it checks every project
+against the projects, ignoring case, and writes it as the Projects page writes it. A project typed that is none of them
+saves nothing: the section says so and gives back what was typed, with the fold open. A form that names a container or a
+source that is not acceptable (one of lastcall's steps), or a suggestion for a project that does not exist, is refused
+as a forged form, and a button for the ticked ones with none ticked says so.
+
+With more than 6 projects, or while one is set, the Projects page offers a search by name (`search`, in the whole
+repository name, ignoring case) and the filter links All, Active, Inactive and Waiting for you (`show`: pull requests to
+review, decisions in an issue or ideas to choose, as the dashboard lists them), each with its count for the current
+search, and the current one with `aria-current`. The form and the links bring the page back to the bar (`#find`) and
+keep the suggestions' filter (`q`), which in turn keeps these; a search that leaves no project says so, with a link to
+show them all. Also with more than 6 projects, each card's Run now starts folded, like its Settings, so that the cards
+are short: its title is the summary that opens it, and its "?" moves inside, after a line that says what it does.
+
 The state at the top of a project's card, its chip ("active · priority ×2" or "inactive"), is a button in a small form:
 one click turns the project's bursts on or off (`POST /projects/<owner>/<name>/active`). The form says the state that it
 wants and does not flip the one that it finds, so that a page that is out of date never turns the project the wrong way.
diff --git a/README.md b/README.md
index 09c84a3..2808cc9 100644
--- a/README.md
+++ b/README.md
@@ -113,9 +113,13 @@ spending limit at the provider too.
 
 **Models and effort.** Every step asks for a tier: the reviewers for *balanced*; the judge, the implementers and the
 improvement plans for *deep*; your repository's own reviewers for the one they name. Each engine has a default
-model and effort per tier, such as opus at `high` effort for Claude Code's *deep*. On the Accounts page, under
+model and effort per tier, such as opus at `xhigh` effort for Claude Code's *deep*. The efforts differ because the
+work does: *deep* runs at `xhigh` because quality matters most there and the quota would expire anyway, *balanced* at
+`high`, and *fast*, which only your repository's own reviewers ask for, at `medium`. On the Accounts page, under
 *Models and effort*, or with `lastcall account tier`, you can change both for one account, subscriptions included.
-More effort finds more, and spends more of the quota.
+The Model field suggests names and takes any other you type: the ones that the engine's CLI takes or, for an API key,
+the models that [models.dev](https://models.dev) lists for its provider. More effort finds more, and spends more of
+the quota.
 
 The rest of lastcall only knows the engine contract. Adding another tool is one module and a few small changes:
 [CONTRIBUTING.md](CONTRIBUTING.md#adding-an-engine) lists them.
@@ -169,6 +173,8 @@ Projects, and Settings holds a fourth that is optional:
 - 📁 **Projects.** lastcall suggests your repositories and says why. Tick the ones you want, or add the suggested ones
   or all of them at once, with a filter when you have many. Any other repository goes in by its address. A click on
   a project's state turns its bursts on or off, and its trash button removes it from lastcall but keeps its history.
+  With many projects, a search by name and the links All, Active, Inactive and Waiting for you (each with its count)
+  keep the list short, and each card's Run now starts folded.
 - 🔔 **Settings.** Where lastcall should notify you. Choose the service and fill in what it asks for: Telegram (paste
   your bot's token and lastcall finds your chat), ntfy, Discord, Slack or email, or any of the
   [services that Apprise reaches](https://github.com/caronc/apprise#supported-notifications). lastcall saves a
@@ -341,10 +347,14 @@ code where they happen, and the reviewers look for their causes first. Projects
 first. The messages are masked before they reach a model.
 
 **Container logs.** If your apps run in Docker on the same machine as lastcall, it can read their logs too, with or
-without a tracker, and with no change to their code. On the Settings page, under *Container logs*, choose the
-project of each container to read, and save. lastcall lists the machine's containers and suggests a project for
-each from its image (`ghcr.io/owner/name`), its Compose project or its name. It reads none until you save, and it
-remembers when you say no to a suggestion. In the terminal: `lastcall logs list`, then
+without a tracker, and with no change to their code. On the Settings page, under *Container logs*, lastcall lists the
+machine's containers in three parts, so that dozens of them stay short. *Read now* comes first: the containers that
+lastcall reads, each with its project and how it was chosen, and a button to stop reading one. Then come the suggested
+ones, which lastcall matched to a project from the container's image (`ghcr.io/owner/name`), its Compose project or
+its name: tick the ones to read, or read all of them at once. The rest wait in a fold that says how many they are,
+with a filter by name: type a project next to a container to read it, and the list of your projects narrows as you
+type. lastcall reads none until you choose it, and it remembers when you skip a suggestion or stop reading a
+container. lastcall's own containers never show there. In the terminal: `lastcall logs list`, then
 `lastcall logs set <container> <owner/name>`.
 
 You can also keep the choice in the app's compose file: label its containers with the project's name, as the
@@ -371,7 +381,9 @@ collects their logs, lastcall reads them there, with nothing to install on those
 1. On the Settings page, under *Logs in Loki*, give Loki's address and, if it asks for one, a login that can only
    read. In Grafana Cloud, that is the user number of your Loki and a token with the `logs:read` scope.
 2. lastcall lists the sources that Loki saw in the last 7 days, named by their `container` label when they have one,
-   and suggests the project of each, as for the containers on its own machine. Choose them, and save.
+   in the same three parts as the containers on its own machine: *Read now*, the suggested ones, which you tick (or
+   read all at once), and the rest in a fold with a filter by name, where you type a project next to a source. Each
+   shows the machines where it ran and its Compose project.
 
 It asks Loki only for the lines of the last day that may be part of an error, the newest 5,000 of each source, and
 reads them as it reads a container's. In the terminal: `lastcall loki connect --url http://<host>:3100`,
@@ -387,7 +399,9 @@ in lastcall only, never in `.lastcall.yml`, so that nobody can turn them on from
   later run, on the current code.
 - **Watch after the merge.** For a day after a merge, lastcall looks at the checks of the merged commit and, if you
   give one, at a health address every 10 minutes. When the checks fail where they passed before, or the address
-  fails 3 times in a row, it opens a pull request that reverts the change, pauses the project and tells you.
+  fails 3 times in a row, it opens a pull request that reverts the change, pauses the project and tells you. Nothing
+  else takes part in the watch: container logs, Loki and your error tracker feed the audits, which use them to find
+  the causes of errors.
 
 Both need the GitHub App to read checks and commit statuses, which Apps created by lastcall 0.7.2 or later have; the
 Projects page says what to do for an older App.
@@ -457,7 +471,8 @@ With a local model on Ollama, it goes to no model provider.
 The names and versions of your dependencies go to [osv.dev](https://osv.dev) in every audit, and to
 [deps.dev](https://deps.dev) for upgrades. The agents' steps reach nothing beyond the allowlist in
 [egress/filter](egress/filter), and errors from production are masked before they reach a model. lastcall itself
-sends no telemetry.
+sends no telemetry. Opening the Accounts page makes it ask [models.dev](https://models.dev), about once a day, for
+the names of the models that an API key's provider offers, in a request that carries nothing of yours.
 
 ### What if a file in my repository tricks the agent?
 
diff --git a/src/lastcall/catalog.py b/src/lastcall/catalog.py
new file mode 100644
index 0000000..ce0eb5a
--- /dev/null
+++ b/src/lastcall/catalog.py
@@ -0,0 +1,89 @@
+"""models.dev's public catalog of models (https://models.dev/api.json), where OpenCode reads what each model costs.
+The web UI reads from it which models an API key's provider offers, to suggest them in the model fields
+(DESIGN.md, section 6).
+
+The catalog is one JSON object, `{provider id: {"models": {model id: {...}}}}`. Of each model lastcall looks at three
+things: `tool_call`, since a step runs on tools; `cost`, since the monthly budget counts what each step costs, so a
+model with no price cannot run; and `status`, since a deprecated model is not worth suggesting. It suggests only the
+ids that an account's model field takes (`accounts.MODEL`). Anything else in the catalog is ignored, and an answer
+that does not look like this counts as no models.
+
+The answer weighs 6 MB, or 0.6 MB gzipped, so the request asks for gzip. The reading is bounded: neither the answer
+nor what it unpacks to may pass `MAX_BYTES`, and a provider keeps `MAX_MODELS` models at most.
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.request
+import zlib
+from collections.abc import Iterable
+
+from lastcall import __version__
+from lastcall.accounts import MODEL
+from lastcall.github import Fetch
+
+URL = "https://models.dev/api.json"
+AGENT = f"lastcall/{__version__} (+https://github.com/ne0x86/lastcall)"  # without a User-Agent, models.dev says 403
+MAX_BYTES = 32 * 1024 * 1024  # the most that the answer may weigh, packed or unpacked
+MAX_MODELS = 1000  # the most that one provider keeps: OpenRouter lists the most, about 300
+
+
+def request(timeout: float) -> urllib.request.Request:
+    req = urllib.request.Request(URL)
+    req.add_header("User-Agent", AGENT)
+    req.add_header("Accept", "application/json")
+    req.add_header("Accept-Encoding", "gzip")
+    req.timeout = timeout  # read by github.urlopen; a fake fetch ignores it
+    return req
+
+
+def models(fetch: Fetch, providers: Iterable[str], timeout: float) -> dict[str, tuple[str, ...]]:
+    """The models that models.dev lists for each of `providers`, sorted, from one request to `fetch`: the ones that a
+    step can run on, `MAX_MODELS` at most. A provider that the catalog does not list gets none. Raises what `fetch`
+    raises, or ValueError, or zlib.error, when the answer cannot be read."""
+    status, headers, raw = fetch(request(timeout))
+    if status != 200:
+        raise ValueError(f"models.dev answered {status}")
+    if len(raw) > MAX_BYTES:
+        raise ValueError("the answer of models.dev is too big")
+    if any(name.lower() == "content-encoding" and value.strip().lower() == "gzip" for name, value in headers.items()):
+        raw = gunzip(raw)
+    catalog = json.loads(raw)
+    if not isinstance(catalog, dict):
+        raise ValueError("models.dev did not answer with its catalog")
+    return {name: suggestions(catalog.get(name)) for name in providers}
+
+
+def gunzip(packed: bytes) -> bytes:
+    """What a gzipped answer unpacks to. A few KB can unpack to gigabytes, so more than `MAX_BYTES` is refused."""
+    inflater = zlib.decompressobj(wbits=zlib.MAX_WBITS | 16)
+    unpacked = inflater.decompress(packed, MAX_BYTES + 1)
+    if len(unpacked) > MAX_BYTES:
+        raise ValueError("the answer of models.dev is too big")
+    return unpacked
+
+
+def suggestions(provider: object) -> tuple[str, ...]:
+    """The ids of the models in a provider's entry of the catalog that a step can run on, in alphabetical order."""
+    listed = provider.get("models") if isinstance(provider, dict) else None
+    if not isinstance(listed, dict):
+        return ()
+    found = [name for name, model in listed.items() if isinstance(name, str) and usable(name, model)]
+    return tuple(sorted(found, key=lambda name: (name.casefold(), name))[:MAX_MODELS])
+
+
+def usable(name: str, model: object) -> bool:
+    """Whether a step can run on this model and an account may name it: it calls tools, it has a price (free is a
+    price) and it is not deprecated."""
+    if not isinstance(model, dict) or not MODEL.fullmatch(name):
+        return False
+    return model.get("tool_call") is True and model.get("status") != "deprecated" and priced(model.get("cost"))
+
+
+def priced(cost: object) -> bool:
+    """Whether a cost entry of the catalog has the price of what goes in and of what comes out."""
+    if not isinstance(cost, dict):
+        return False
+    prices = [cost.get("input"), cost.get("output")]
+    return all(isinstance(price, int | float) and not isinstance(price, bool) for price in prices)
diff --git a/src/lastcall/data/tiers.json b/src/lastcall/data/tiers.json
index 97873e6..4ed4d6b 100644
--- a/src/lastcall/data/tiers.json
+++ b/src/lastcall/data/tiers.json
@@ -1,14 +1,19 @@
 {
-  "_about": "Default model and effort for each tier, per engine (DESIGN.md, section 6), and the effort levels that each engine's CLI takes. Catalogs change every month: update this file, not the code. An account can override any tier's model and effort.",
+  "_about": "Default model and effort for each tier, per engine (DESIGN.md, section 6), the model names that each engine's CLI takes and the effort levels that it takes. Catalogs change every month: update this file, not the code. An account can override any tier's model and effort. The effort follows the work: fast is only asked for by a repository's own reviewers, balanced runs the reviewers and deep runs the judge, the implementers and the improvement plans, where quality matters most.",
   "claude-code": {
     "fast": ["haiku", "medium"],
     "balanced": ["sonnet", "high"],
-    "deep": ["opus", "high"]
+    "deep": ["opus", "xhigh"]
   },
   "codex": {
-    "fast": ["gpt-6-luna", "high"],
+    "fast": ["gpt-6-luna", "medium"],
     "balanced": ["gpt-6.1-sol", "high"],
-    "deep": ["gpt-6.1-sol", "high"]
+    "deep": ["gpt-6.1-sol", "xhigh"]
+  },
+  "models": {
+    "_about": "Names that each engine's CLI takes: the Accounts page suggests them for the model of a tier, and an owner can type any other. Claude Code: the aliases, which mean the newest model of their family on the Anthropic API. `fable` is left out on purpose, since `claude -p` can bill a Fable request to usage credits without asking. Codex: the models that its own catalog lists for choosing (`codex debug models --bundled`) and has not replaced with a newer one, in the order of its picker. An API key's models come from models.dev instead, and a local model server's are the owner's.",
+    "claude-code": ["haiku", "sonnet", "opus"],
+    "codex": ["gpt-6.1-sol", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna"]
   },
   "efforts": {
     "_about": "Lowest first. Claude Code's --effort; Codex's model_reasoning_effort; OpenCode's --variant, whose levels depend on the model.",
diff --git a/src/lastcall/engines/base.py b/src/lastcall/engines/base.py
index 1b0820a..87030cd 100644
--- a/src/lastcall/engines/base.py
+++ b/src/lastcall/engines/base.py
@@ -102,6 +102,7 @@ class Provider:
     title: str  # as people know it: "OpenRouter"
     keys: str  # where the owner creates an API key; "" for a local model server, which needs none
     models: str  # where the owner finds the names of its models
+    catalog: str = ""  # its id in models.dev, whose catalog lists its models; "" when there is none to ask
 
 
 @runtime_checkable
diff --git a/src/lastcall/engines/opencode.py b/src/lastcall/engines/opencode.py
index 037c283..386d946 100644
--- a/src/lastcall/engines/opencode.py
+++ b/src/lastcall/engines/opencode.py
@@ -37,19 +37,27 @@
 KEY_FILE = f"{CONTEXT_DIR}/key"
 LOCAL = "ollama"  # local models: an OpenAI-compatible server, by default the compose service `ollama`
 LOCAL_URL = "http://ollama:11434/v1"
-PROVIDERS = (
-    Provider("openrouter", "OpenRouter", "https://openrouter.ai/settings/keys", "https://openrouter.ai/models"),
+PROVIDERS = (  # the models.dev id of each API is its name; a local model server has no catalog to ask
+    Provider(
+        "openrouter",
+        "OpenRouter",
+        "https://openrouter.ai/settings/keys",
+        "https://openrouter.ai/models",
+        "openrouter",
+    ),
     Provider(
         "anthropic",
         "Anthropic API",
         "https://platform.claude.com/settings/keys",
         "https://platform.claude.com/docs/en/models/overview",
+        "anthropic",
     ),
     Provider(
         "openai",
         "OpenAI API",
         "https://platform.openai.com/api-keys",
         "https://developers.openai.com/api/docs/models",
+        "openai",
     ),
     Provider(LOCAL, "Ollama", "", "https://ollama.com/library"),
 )
diff --git a/src/lastcall/locales/en.json b/src/lastcall/locales/en.json
index 3ef18d0..ebe190b 100644
--- a/src/lastcall/locales/en.json
+++ b/src/lastcall/locales/en.json
@@ -231,6 +231,17 @@
   "web.projects.never": "never",
   "web.projects.no_findings": "none yet",
   "web.projects.none": "No projects yet.",
+  "web.projects.search": "Search by name",
+  "web.projects.search_go": "Search",
+  "web.projects.show": "Show projects",
+  "web.projects.filter.all": "All",
+  "web.projects.filter.active": "Active",
+  "web.projects.filter.inactive": "Inactive",
+  "web.projects.filter.waiting": "Waiting for you",
+  "web.projects.showing.one": "Showing {shown} of {count} project.",
+  "web.projects.showing.other": "Showing {shown} of {count} projects.",
+  "web.projects.no_match": "No project matches this search and filter.",
+  "web.projects.show_all": "Show all projects",
 
   "web.finding.pending.one": "{count} pending",
   "web.finding.pending.other": "{count} pending",
@@ -293,8 +304,9 @@
   "web.project.weight.high": "High (×2)",
   "web.project.weight.top": "Highest (×3)",
   "web.project.weight.custom": "×{weight}",
-  "web.project.language": "Writes in",
-  "web.project.language.account": "The account's",
+  "web.project.language": "Language of its pull requests and issues",
+  "web.project.language.account": "Same as the account",
+  "web.project.language_hint": "“Same as the account” uses the language of whichever account works on it, set on the Accounts page.",
   "web.project.merge_on_approve": "Merge after my approval",
   "web.project.watch": "Watch after the merge",
   "web.project.tests": "Tests too",
@@ -426,7 +438,7 @@
   "web.accounts.id": "Name",
   "web.accounts.id_hint": "Lowercase letters, digits and dashes, such as claude-max.",
   "web.accounts.engine": "Subscription",
-  "web.accounts.language_label": "Writes in",
+  "web.accounts.language_label": "Language of its pull requests and issues",
   "web.accounts.reserve_label": "Reserve for you, % of every week",
   "web.accounts.enabled": "lastcall may spend it",
   "web.accounts.submit": "Add",
@@ -459,6 +471,7 @@
   "web.accounts.model_hint": "The model of every step, as the provider's list names it. lastcall counts what each step costs, so the model needs a price in that list.",
   "web.accounts.review_label": "Reviewers' model (optional)",
   "web.accounts.review_hint": "A cheaper model for the reviewers. Empty: the model above.",
+  "web.accounts.model_suggest": "The field suggests what models.dev lists for all the providers, and OpenRouter writes the maker first, as in qwen/qwen3-coder. Pick one from the provider you chose, or type any other.",
   "web.accounts.budget_label": "Monthly budget, USD",
   "web.accounts.budget_hint": "What its steps may cost each calendar month (UTC), whatever its policy. A step that is already running may go a little over it: keep the provider's own limit too.",
   "web.accounts.policy_label": "When it spends",
@@ -560,24 +573,43 @@
   "web.signals.failed": "The tracker did not answer as expected: {error}",
   "web.logs.title": "Container logs",
   "web.logs.intro": "If your apps run in Docker on this same machine, lastcall can read their containers' logs, with no change to your apps: the errors, grouped by kind, and the restarts.",
-  "web.logs.step1": "Choose the project of each container that you want read. lastcall suggests one from the container's image (ghcr.io/owner/name), its Compose project or its name, and reads nothing until you save.",
+  "web.logs.step1": "lastcall suggests a project for each container from its image (ghcr.io/owner/name), its Compose project or its name. It reads none until you choose it: tick the suggestions to read them, or type a project next to any other container.",
   "web.logs.step2": "lastcall then reads the last 24 hours of those containers, every 30 minutes and before each run: only their logs and state, never anything else of them.",
   "web.logs.project": "Project",
-  "web.logs.not_read": "None: not read",
-  "web.logs.suggested": "Suggested: {project}. Save to read it.",
-  "web.logs.from_label": "Read for {project}, from its label.",
   "web.logs.save": "Save",
-  "web.logs.none": "No containers on this machine.",
+  "web.logs.none": "No containers on this machine besides lastcall's own.",
   "web.logs.unavailable": "The containers can be listed only when lastcall runs with docker compose.",
   "web.logs.failed": "The containers could not be listed: {error}",
+  "web.logs.read_title": "Read now",
+  "web.logs.read_none": "Nothing is read yet.",
+  "web.logs.chosen_here": "chosen here",
+  "web.logs.label_decides": "its label decides",
+  "web.logs.label_unknown": "Its label names {project}, which is not a project: add it on the Projects page and it is read.",
+  "web.logs.stop": "Stop reading",
+  "web.logs.stop_label": "Stop reading {name}",
+  "web.logs.suggested_title": "Suggested",
+  "web.logs.for_project": "for {project}",
+  "web.logs.read_suggested.one": "Read the suggested one",
+  "web.logs.read_suggested.other": "Read the {count} suggested",
+  "web.logs.read_ticked": "Read the ticked",
+  "web.logs.skip_ticked": "Skip the ticked",
+  "web.logs.others.one": "{count} other container",
+  "web.logs.others.other": "{count} other containers",
+  "web.logs.matching.one": "{shown} of {count} matches “{query}”.",
+  "web.logs.matching.other": "{shown} of {count} match “{query}”.",
+  "web.logs.others_hint": "Type a project next to each one that you want read, then save.",
+  "web.logs.pick_placeholder": "Type to find a project",
+  "web.logs.project_for": "Project for {name}",
+  "web.logs.not_a_project": "“{project}” is not one of your projects. Pick one from the list that opens as you type: the name is the one the Projects page writes.",
+  "web.logs.none_ticked": "Tick at least one container.",
   "web.logs.label_title": "Or with a label in the compose file",
-  "web.logs.label_how": "Both ways work together. A container with the label lastcall.project is read for that project with nothing to choose: this page shows it with its project. Add it to the app's compose file, with the project's name as the Projects page writes it, and run docker compose up -d for that app:",
+  "web.logs.label_how": "Both ways work together. A container with the label lastcall.project is read for that project with nothing to choose: this page shows it under “Read now”, and its label decides. Add it to the app's compose file, with the project's name as the Projects page writes it, and run docker compose up -d for that app:",
 
   "web.loki.title": "Logs in Loki",
   "web.loki.intro": "If your apps run on other machines and Grafana Loki already collects their logs, lastcall can read them there, with nothing to install on those machines.",
   "web.loki.step1": "Give Loki's address, one that lastcall can reach, such as http://192.168.1.20:3100, or https://logs-prod-012.grafana.net in Grafana Cloud. lastcall reads it once to check it, and saves it only if that works.",
   "web.loki.step2": "If Loki asks for a login, give its user and a token that can only read. In Grafana Cloud, the user is the number in your Loki's details, and the token needs the logs:read scope. A Loki with no login needs neither.",
-  "web.loki.step3": "Choose the project of each source, and save. lastcall suggests one from the source's name or its Compose project, and reads nothing until you save.",
+  "web.loki.step3": "Choose the sources to read. lastcall suggests a project from a source's name or its Compose project, and reads nothing until you choose.",
   "web.loki.url": "Loki's address",
   "web.loki.user": "User",
   "web.loki.user_hint": "Only for a Loki with a login.",
@@ -599,6 +631,9 @@
   "web.loki.choose_label": "Choose a label",
   "web.loki.use_label": "Use this label",
   "web.loki.none": "Loki saw no streams with this label in the last 7 days.",
+  "web.loki.others.one": "{count} other source",
+  "web.loki.others.other": "{count} other sources",
+  "web.loki.none_ticked": "Tick at least one source.",
   "web.loki.compose": "Compose project: {project}",
 
   "web.tiers.title": "Models and effort",
@@ -617,6 +652,8 @@
   "web.tiers.keyed_hint": "OpenCode passes the effort as the model's variant: choose one that your model offers, or keep Default.",
   "web.tiers.save": "Save models and effort",
   "web.tiers.need_models": "Give a model for each level: an account on an API key or a local model has no default.",
+  "web.tiers.suggest.cli": "The Model field suggests the names that {tool} takes. Pick one, or type any other.",
+  "web.tiers.suggest.catalog": "The Model field suggests what models.dev lists for {provider}: models that use tools and have a price. Pick one, or type any other.",
 
   "web.time.now": "just now",
   "web.time.ago": "{span} ago",
@@ -637,6 +674,7 @@
   "web.add.placeholder": "owner/name",
   "web.error.signin": "Back to sign in",
   "web.project.run_now": "Run now",
+  "web.project.run_summary": "Starts a run right away, on the account you choose.",
   "web.project.settings_summary": "Settings",
   "web.projects.intro": "lastcall works on these repositories when an account has quota it would lose. Choose what it may do in each one.",
   "web.projects.empty": "No projects yet. Pick one of your repositories below: lastcall says why each one is worth it.",
@@ -681,7 +719,7 @@
   "web.help.common.terminal.title": "Where to type it",
   "web.help.accounts.check.title": "Reading the quota",
   "web.help.settings.loki_sources.title": "Sources",
-  "web.help.projects.turns.title": "Tests and upgrades in turn",
+  "web.help.projects.turns.title": "Tests and dependencies in turn",
   "web.help.projects.tickets.title": "Labelled issues",
   "web.help.projects.score.title": "Points",
   "web.help.projects.size.title": "Tokens of code",
@@ -717,12 +755,12 @@
   "web.help.dashboard.status": "Status: stopped early means that before a step the account had reached your reserve or its monthly budget, had paid usage on, or had no quota reading, so the run ended there. Interrupted means lastcall itself stopped while the run was going, for example at a restart. Failed means an error stopped it.",
   "web.help.projects.active": "Active projects take part in bursts. Even then, a burst skips a project while it has 2 lastcall pull requests waiting for you, or when the same account audited it in the last 7 days, unless you ticked ideas or labelled issues for it. The run buttons work even when the project is inactive. Click the state at the top of a card to turn bursts on or off; the “Active” box in Settings does the same.",
   "web.help.projects.weight": "When an account has quota to spend, lastcall gives each active project points (never audited by that account, days and new commits since its last audit, pending findings, errors in production, what you asked for) and starts with the highest. Priority multiplies those points: High (×2) doubles them, Low (×0.5) halves them. It does not make a run longer.",
-  "web.help.projects.language": "The language of this project's pull requests, issues and reports. With “The account's”, lastcall writes in the language of whichever account does the run, set on the Accounts page. It does not change these pages or your notifications.",
+  "web.help.projects.language": "The language of this project's pull requests, issues and reports. With “Same as the account”, lastcall writes in the language of whichever account does the run, set on the Accounts page. It does not change these pages or your notifications.",
   "web.help.projects.max_prs": "The most pull requests one run opens on this project, whatever it does: an audit, tests, dependency upgrades, the ideas of a plan or labelled issues. What does not fit waits for a later run.",
-  "web.help.projects.merge_on_approve": "On GitHub, approving a pull request does not merge it. With this on, lastcall merges its own pull requests (never a revert) once someone who can write to the repository approves the latest commit, nobody with write access asks for changes, and no check fails or is still running. If one no longer merges cleanly, lastcall closes it and a later run makes the change again on the current code.",
-  "web.help.projects.watch": "For a day after one of lastcall's pull requests is merged, lastcall watches the checks of the merged commit and the health address below. If the checks fail where they passed before, or the address fails 3 times in a row, it opens a pull request that reverts the change, pauses the project (unticks “Active”) and tells you. It never merges the revert: you decide.",
+  "web.help.projects.merge_on_approve": "On GitHub, approving a pull request does not merge it. With this on, lastcall merges its own pull requests (never a revert) at its next look at GitHub, which is every 10 minutes: once someone who can write to the repository has approved the latest commit, nobody with write access asks for changes, and no check fails or is still running. If GitHub does not let it merge yet, for example because a rule of a protected branch is not met, lastcall waits. If one no longer merges cleanly, lastcall closes it and a later run makes the change again on the current code. Without this, you merge them yourself.",
+  "web.help.projects.watch": "For a day after one of lastcall's pull requests is merged, lastcall watches two things only: the checks of the merged commit and, if you give one, the health address below. If the checks fail where they passed before, or the address fails 3 times in a row, it opens a pull request that reverts the change, pauses the project (unticks “Active”) and tells you. It never merges the revert: you decide. Container logs, Loki and your error tracker take no part in the watch: they feed the audits, which use them to find the causes of errors.",
   "web.help.projects.health_url": "Used only while “Watch after the merge” is on and a merge is being watched. lastcall asks it every 10 minutes; any answer with a status from 200 to 399 within 10 seconds counts as working.",
-  "web.help.projects.turns": "Bursts on this project take turns: an audit, then tests, then dependency upgrades (each only if ticked), then an audit again. Tests too adds tests for behavior no test checks. Dependencies too upgrades what needs more than a new version number: known vulnerabilities, deprecated packages, major versions behind. Ideas you ticked in a plan and issues labelled lastcall always go first.",
+  "web.help.projects.turns": "The ideas you ticked in a plan and the issues labelled lastcall always go first. After them, a burst on this project audits it. Tick “Tests too”, “Dependencies too” or both, and the bursts take turns: an audit, then a run that writes tests, then one that upgrades dependencies (each only if ticked), then an audit again. A tests run opens pull requests that only add tests, for behavior no test checks. A dependencies run opens pull requests that upgrade what needs more than a new version number (a known vulnerability, a deprecated package, a major version behind, a runtime past its end of life) and fix the code that the new version breaks; plain minor and patch upgrades are left to bots such as Dependabot. The buttons “Write tests now” and “Upgrade dependencies now” run them at once, ticked or not.",
   "web.help.projects.signals": "Its short name in the tracker's URLs. lastcall reads this project's unresolved errors with a read-only token: a project with errors in the last day ranks higher, and its audits see the error's type, its message with personal data masked, and the lines of your own code. Request data, user data and local variables never reach a model.",
   "web.help.projects.account": "Any free account takes the account that is not running anything and has the most quota left before its reset. Choose an account to use that one.",
   "web.help.projects.account_all": "With the option for all free accounts, every free account reviews the project and the one with the most quota left judges the findings and writes the fixes. Only an audit can use them all: for Improve now, tests and upgrades it means any free account.",
@@ -750,9 +788,10 @@
   "web.help.settings.language": "Saved in this browser for a year. Until you choose, lastcall follows your browser's language. Your notifications have their own language, under Notifications, and what lastcall writes on GitHub follows each account and project.",
   "web.help.settings.notify_language": "The language of the messages lastcall sends you, whatever language these pages show. Until you save one, lastcall takes the language of these pages when you add your first destination.",
   "web.help.settings.signals_project": "In Sentry and GlitchTip, each app sends its errors to a project with a short name in its URLs. Give that name to a lastcall project on the Projects page: its audits then read its unresolved errors of the last 14 days, the most frequent first.",
-  "web.help.settings.logs_project": "The list holds the repositories on your Projects page. lastcall reads a container's logs only once you give it a project. Saving “None: not read” on a container lastcall proposed records your no, so the proposal does not come back.",
+  "web.help.settings.logs_project": "Type to narrow the list, which holds the repositories on your Projects page: write one as that page does, in any case. Anything else is refused. lastcall reads the logs of a container, or of a source, only once you give it a project.",
+  "web.help.settings.logs_suggested": "lastcall pairs a container, or a source in Loki, with one of your projects from its image, its Compose project or its name, when only one project fits. It reads nothing until you read it here. Skipping a suggestion records your no, so that it does not come back; you can still give it a project below, among the others.",
   "web.help.settings.loki_label": "Loki tags each stream of logs with labels. lastcall lists the values of one label as sources, one per app or container, seen in the last 7 days. It uses the first that your Loki has of container, container_name, service_name, app and job. Choose another only if your apps go by a different label: your project choices then start over.",
-  "web.help.settings.loki_sources": "The names next to each source are the machines where it ran, from the host label of its logs. The Compose project, when Loki has it, is one of the clues lastcall uses to propose a project; it reads nothing until you save one.",
+  "web.help.settings.loki_sources": "The names next to each source are the machines where it ran, from the host label of its logs. The Compose project, when Loki has it, is one of the clues lastcall uses to propose a project; it reads nothing until you choose one.",
   "web.help.settings.loki_tenant": "Leave it empty unless your Loki keeps the logs of several teams apart (multi-tenant) and its admin gave you a tenant name. lastcall sends it in the X-Scope-OrgID header of every request.",
   "web.help.settings.loki_token": "With a user, lastcall signs in with that user and this password (basic login). Without a user, it sends this as a bearer token, the way a token-protected Loki or proxy expects.",
   "web.help.settings.destination": "Each line is the destination as Apprise, the library that sends lastcall's notifications, writes it, with its secrets hidden. The full address stays in lastcall's secret store.",
@@ -792,14 +831,14 @@
   "web.project.legend.when": "When lastcall works on it",
   "web.project.legend.writes": "What it writes and may do",
   "web.project.active_hint": "Bursts may pick it. The run buttons work either way.",
-  "web.project.merge_hint": "lastcall merges its own pull requests once they are approved and their checks pass.",
-  "web.project.watch_hint": "For a day after a merge, if the checks or the health address break, lastcall proposes a revert and pauses the project.",
+  "web.project.merge_hint": "When you approve one of its pull requests on GitHub, lastcall merges it once its checks pass. Without this, you merge it yourself.",
+  "web.project.watch_hint": "For a day after a merge, lastcall watches only the merged commit's checks and the health address below, not your logs or error tracker. If either breaks, it proposes a revert and pauses the project.",
   "web.project.checks.lead": "“{merge}” and “{watch}” need the GitHub App to read checks and commit statuses, and this App cannot yet.",
   "web.project.checks.open": "Open the App's permissions on GitHub.",
   "web.project.checks.set": "Set “Checks” and “Commit statuses” to “Read-only” and save.",
   "web.project.checks.accept": "Accept the new permissions where GitHub asks for it, on the App's installation: Settings › Applications › Installed GitHub Apps › Configure, or the organization's settings.",
-  "web.project.tests_turn": "In turn with the audits, it adds tests for behavior that no test checks.",
-  "web.project.deps_turn": "In turn with the audits, it upgrades what needs more than a new version number.",
+  "web.project.tests_turn": "Some bursts write tests instead of auditing: pull requests that add tests for behavior no test checks.",
+  "web.project.deps_turn": "Some bursts upgrade dependencies instead of auditing: pull requests for what needs more than a new version number.",
   "web.project.run_hints": "What each button does",
   "web.settings.events_hint": "They apply once you add a destination above.",
   "web.nav.breadcrumb": "Breadcrumb",
diff --git a/src/lastcall/locales/es.json b/src/lastcall/locales/es.json
index 833f31c..1fc91a1 100644
--- a/src/lastcall/locales/es.json
+++ b/src/lastcall/locales/es.json
@@ -231,6 +231,17 @@
   "web.projects.never": "nunca",
   "web.projects.no_findings": "ninguno aún",
   "web.projects.none": "Aún no hay proyectos.",
+  "web.projects.search": "Buscar por nombre",
+  "web.projects.search_go": "Buscar",
+  "web.projects.show": "Mostrar proyectos",
+  "web.projects.filter.all": "Todos",
+  "web.projects.filter.active": "Activos",
+  "web.projects.filter.inactive": "Inactivos",
+  "web.projects.filter.waiting": "Pendientes de ti",
+  "web.projects.showing.one": "Mostrando {shown} de {count} proyecto.",
+  "web.projects.showing.other": "Mostrando {shown} de {count} proyectos.",
+  "web.projects.no_match": "Ningún proyecto coincide con esta búsqueda y este filtro.",
+  "web.projects.show_all": "Ver todos los proyectos",
 
   "web.finding.pending.one": "{count} pendiente",
   "web.finding.pending.other": "{count} pendientes",
@@ -293,8 +304,9 @@
   "web.project.weight.high": "Alta (×2)",
   "web.project.weight.top": "Máxima (×3)",
   "web.project.weight.custom": "×{weight}",
-  "web.project.language": "Escribe en",
-  "web.project.language.account": "El de la cuenta",
+  "web.project.language": "Idioma de sus pull requests e issues",
+  "web.project.language.account": "Igual que la cuenta",
+  "web.project.language_hint": "«Igual que la cuenta» usa el idioma de la cuenta que trabaje en él, el que se elige en Cuentas.",
   "web.project.merge_on_approve": "Fusionar tras mi aprobación",
   "web.project.watch": "Vigilar tras la fusión",
   "web.project.tests": "También tests",
@@ -426,7 +438,7 @@
   "web.accounts.id": "Nombre",
   "web.accounts.id_hint": "Minúsculas, dígitos y guiones, como claude-max.",
   "web.accounts.engine": "Suscripción",
-  "web.accounts.language_label": "Escribe en",
+  "web.accounts.language_label": "Idioma de sus pull requests e issues",
   "web.accounts.reserve_label": "Reserva para ti, % de cada semana",
   "web.accounts.enabled": "lastcall puede gastarla",
   "web.accounts.submit": "Añadir",
@@ -459,6 +471,7 @@
   "web.accounts.model_hint": "El modelo de todos los pasos, tal como lo nombra la lista del proveedor. lastcall cuenta lo que cuesta cada paso, así que el modelo necesita un precio en esa lista.",
   "web.accounts.review_label": "Modelo de los revisores (opcional)",
   "web.accounts.review_hint": "Un modelo más barato para los revisores. Vacío: el de arriba.",
+  "web.accounts.model_suggest": "El campo sugiere lo que models.dev lista para todos los proveedores, y OpenRouter escribe primero el fabricante, como en qwen/qwen3-coder. Elige uno del proveedor que seleccionaste, o escribe cualquier otro.",
   "web.accounts.budget_label": "Presupuesto mensual, USD",
   "web.accounts.budget_hint": "Lo que pueden costar sus pasos cada mes natural (UTC), sea cual sea su política. Un paso que ya está en marcha puede pasarse un poco: mantén también el límite del proveedor.",
   "web.accounts.policy_label": "Cuándo gasta",
@@ -560,24 +573,43 @@
   "web.signals.failed": "El tracker no respondió como se esperaba: {error}",
   "web.logs.title": "Logs de los contenedores",
   "web.logs.intro": "Si tus apps corren en Docker en esta misma máquina, lastcall puede leer los logs de sus contenedores, sin cambiar nada de tus apps: los errores, agrupados por tipo, y los reinicios.",
-  "web.logs.step1": "Elige el proyecto de cada contenedor que quieras que lea. lastcall sugiere uno por la imagen del contenedor (ghcr.io/owner/name), su proyecto de Compose o su nombre, y no lee nada hasta que guardes.",
+  "web.logs.step1": "lastcall sugiere un proyecto para cada contenedor por su imagen (ghcr.io/owner/name), su proyecto de Compose o su nombre. No lee ninguno hasta que lo elijas: marca las sugerencias para leerlas, o escribe un proyecto junto a cualquier otro contenedor.",
   "web.logs.step2": "Desde entonces lastcall lee las últimas 24 horas de esos contenedores, cada 30 minutos y antes de cada ejecución: solo sus logs y su estado, nunca nada más de ellos.",
   "web.logs.project": "Proyecto",
-  "web.logs.not_read": "Ninguno: no se lee",
-  "web.logs.suggested": "Sugerido: {project}. Guarda para leerlo.",
-  "web.logs.from_label": "Se lee para {project}, por su etiqueta.",
   "web.logs.save": "Guardar",
-  "web.logs.none": "No hay contenedores en esta máquina.",
+  "web.logs.none": "No hay más contenedores en esta máquina que los del propio lastcall.",
   "web.logs.unavailable": "Los contenedores solo se pueden listar cuando lastcall corre con docker compose.",
   "web.logs.failed": "No se pudieron listar los contenedores: {error}",
+  "web.logs.read_title": "Se lee ahora",
+  "web.logs.read_none": "Todavía no se lee nada.",
+  "web.logs.chosen_here": "elegido aquí",
+  "web.logs.label_decides": "lo decide su etiqueta",
+  "web.logs.label_unknown": "Su etiqueta nombra a {project}, que no es un proyecto: añádelo en la página de proyectos y se lee.",
+  "web.logs.stop": "Dejar de leer",
+  "web.logs.stop_label": "Dejar de leer {name}",
+  "web.logs.suggested_title": "Sugeridos",
+  "web.logs.for_project": "para {project}",
+  "web.logs.read_suggested.one": "Leer el sugerido",
+  "web.logs.read_suggested.other": "Leer los {count} sugeridos",
+  "web.logs.read_ticked": "Leer los marcados",
+  "web.logs.skip_ticked": "Descartar los marcados",
+  "web.logs.others.one": "{count} otro contenedor",
+  "web.logs.others.other": "{count} otros contenedores",
+  "web.logs.matching.one": "{shown} de {count} coincide con «{query}».",
+  "web.logs.matching.other": "{shown} de {count} coinciden con «{query}».",
+  "web.logs.others_hint": "Escribe un proyecto junto a cada uno que quieras leer y guarda.",
+  "web.logs.pick_placeholder": "Escribe para buscar un proyecto",
+  "web.logs.project_for": "Proyecto de {name}",
+  "web.logs.not_a_project": "«{project}» no es uno de tus proyectos. Elige uno de la lista que se abre al escribir: el nombre es el que escribe la página de proyectos.",
+  "web.logs.none_ticked": "Marca al menos un contenedor.",
   "web.logs.label_title": "O con una etiqueta en el compose",
-  "web.logs.label_how": "Las dos formas conviven. Un contenedor con la etiqueta lastcall.project se lee para ese proyecto sin elegir nada: esta página lo muestra con su proyecto. Añádela al compose de la app, con el nombre del proyecto tal como lo escribe la página de proyectos, y ejecuta docker compose up -d en esa app:",
+  "web.logs.label_how": "Las dos formas conviven. Un contenedor con la etiqueta lastcall.project se lee para ese proyecto sin elegir nada: esta página lo muestra en «Se lee ahora» y la etiqueta decide. Añádela al compose de la app, con el nombre del proyecto tal como lo escribe la página de proyectos, y ejecuta docker compose up -d en esa app:",
 
   "web.loki.title": "Logs en Loki",
   "web.loki.intro": "Si tus apps corren en otras máquinas y Grafana Loki ya recoge sus logs, lastcall puede leerlos allí, sin instalar nada en esas máquinas.",
   "web.loki.step1": "Da la dirección de Loki, una a la que lastcall llegue, como http://192.168.1.20:3100, o https://logs-prod-012.grafana.net en Grafana Cloud. lastcall la lee una vez para comprobarla y solo la guarda si funciona.",
   "web.loki.step2": "Si Loki pide usuario, da su usuario y un token que solo pueda leer. En Grafana Cloud, el usuario es el número que aparece en los detalles de tu Loki, y el token necesita el permiso logs:read. Un Loki sin usuario no necesita ninguno.",
-  "web.loki.step3": "Elige el proyecto de cada fuente y guarda. lastcall sugiere uno por el nombre de la fuente o su proyecto de Compose, y no lee nada hasta que guardes.",
+  "web.loki.step3": "Elige las fuentes que quieres leer. lastcall sugiere un proyecto por el nombre de la fuente o su proyecto de Compose, y no lee nada hasta que elijas.",
   "web.loki.url": "Dirección de Loki",
   "web.loki.user": "Usuario",
   "web.loki.user_hint": "Solo para un Loki con usuario.",
@@ -599,6 +631,9 @@
   "web.loki.choose_label": "Elige una etiqueta",
   "web.loki.use_label": "Usar esta etiqueta",
   "web.loki.none": "Loki no vio streams con esta etiqueta en los últimos 7 días.",
+  "web.loki.others.one": "{count} otra fuente",
+  "web.loki.others.other": "{count} otras fuentes",
+  "web.loki.none_ticked": "Marca al menos una fuente.",
   "web.loki.compose": "Proyecto de Compose: {project}",
 
   "web.tiers.title": "Modelos y esfuerzo",
@@ -617,6 +652,8 @@
   "web.tiers.keyed_hint": "OpenCode pasa el esfuerzo como variante del modelo: elige una que tu modelo ofrezca, o deja Por defecto.",
   "web.tiers.save": "Guardar modelos y esfuerzo",
   "web.tiers.need_models": "Da un modelo para cada nivel: una cuenta con API key o modelo local no tiene valor por defecto.",
+  "web.tiers.suggest.cli": "El campo Modelo sugiere los nombres que acepta {tool}. Elige uno o escribe cualquier otro.",
+  "web.tiers.suggest.catalog": "El campo Modelo sugiere lo que models.dev lista para {provider}: modelos que usan herramientas y tienen precio. Elige uno o escribe cualquier otro.",
 
   "web.time.now": "ahora mismo",
   "web.time.ago": "hace {span}",
@@ -637,6 +674,7 @@
   "web.add.placeholder": "propietario/nombre",
   "web.error.signin": "Volver a iniciar sesión",
   "web.project.run_now": "Ejecutar ahora",
+  "web.project.run_summary": "Empieza una ejecución ya, en la cuenta que elijas.",
   "web.project.settings_summary": "Ajustes",
   "web.projects.intro": "lastcall trabaja en estos repositorios cuando una cuenta tiene cuota que perdería. Elige qué puede hacer en cada uno.",
   "web.projects.empty": "Aún no hay proyectos. Elige uno de tus repositorios aquí abajo: lastcall dice por qué merece la pena cada uno.",
@@ -717,12 +755,12 @@
   "web.help.dashboard.status": "Estado: parada antes de tiempo significa que, antes de un paso, la cuenta había llegado a tu reserva o a su presupuesto mensual, tenía activo el uso de pago o no tenía lectura de cuota, así que la ejecución terminó ahí. Interrumpida significa que lastcall se detuvo mientras la ejecución estaba en marcha, por ejemplo al reiniciarse. Fallida significa que un error la detuvo.",
   "web.help.projects.active": "Los proyectos activos entran en las ráfagas. Aun así, una ráfaga se salta un proyecto mientras tenga 2 pull requests de lastcall esperándote, o si la misma cuenta lo auditó en los últimos 7 días, salvo que hayas marcado ideas o etiquetado issues para él. Los botones para lanzar una ejecución funcionan aunque el proyecto esté inactivo. Haz clic en el estado, arriba en la tarjeta, para activar o desactivar las ráfagas; la casilla «Activo» de Ajustes hace lo mismo.",
   "web.help.projects.weight": "Cuando una cuenta tiene cuota que gastar, lastcall da puntos a cada proyecto activo (nunca auditado por esa cuenta, días y commits nuevos desde su última auditoría, hallazgos pendientes, errores en producción, lo que hayas pedido) y empieza por el que más tiene. La prioridad multiplica esos puntos: Alta los duplica y Baja los reduce a la mitad. No hace la ejecución más larga.",
-  "web.help.projects.language": "El idioma de los pull requests, issues e informes de este proyecto. Con «El de la cuenta», lastcall escribe en el idioma de la cuenta que haga la ejecución, el que se elige en Cuentas. No cambia estas páginas ni tus notificaciones.",
+  "web.help.projects.language": "El idioma de los pull requests, issues e informes de este proyecto. Con «Igual que la cuenta», lastcall escribe en el idioma de la cuenta que haga la ejecución, el que se elige en Cuentas. No cambia estas páginas ni tus notificaciones.",
   "web.help.projects.max_prs": "El máximo de pull requests que abre una ejecución en este proyecto, haga lo que haga: una auditoría, tests, actualizaciones de dependencias, las ideas de un plan o issues etiquetados. Lo que no cabe espera a una ejecución posterior.",
-  "web.help.projects.merge_on_approve": "En GitHub, aprobar un pull request no lo fusiona. Con esto activado, lastcall fusiona sus propios pull requests (nunca una reversión) cuando alguien con permiso de escritura aprueba el último commit, nadie con ese permiso pide cambios y ningún check falla ni sigue en curso. Si uno ya no se fusiona limpio, lastcall lo cierra y una ejecución posterior rehace el cambio sobre el código actual.",
-  "web.help.projects.watch": "Durante un día después de fusionar uno de los pull requests de lastcall, lastcall vigila los checks del commit fusionado y la dirección de salud de abajo. Si los checks fallan donde antes pasaban, o la dirección falla 3 veces seguidas, abre un pull request que deshace el cambio, pausa el proyecto (desmarca «Activo») y te avisa. Nunca fusiona esa reversión: decides tú.",
+  "web.help.projects.merge_on_approve": "En GitHub, aprobar un pull request no lo fusiona. Con esto activado, lastcall fusiona sus propios pull requests (nunca una reversión) en su siguiente consulta a GitHub, que es cada 10 minutos: cuando alguien con permiso de escritura en el repositorio ha aprobado el último commit, nadie con ese permiso pide cambios y ningún check falla ni sigue en curso. Si GitHub todavía no deja fusionarlo, por ejemplo porque no se cumple una regla de una rama protegida, lastcall espera. Si uno ya no se fusiona limpio, lastcall lo cierra y una ejecución posterior rehace el cambio sobre el código actual. Sin esto, los fusionas tú.",
+  "web.help.projects.watch": "Durante un día después de fusionar uno de los pull requests de lastcall, lastcall vigila solo dos cosas: los checks del commit fusionado y, si das una, la dirección de salud de abajo. Si los checks fallan donde antes pasaban, o la dirección falla 3 veces seguidas, abre un pull request que deshace el cambio, pausa el proyecto (desmarca «Activo») y te avisa. Nunca fusiona esa reversión: decides tú. Los logs de contenedores, Loki y tu tracker de errores no intervienen en la vigilancia: alimentan las auditorías, que los usan para encontrar las causas de los errores.",
   "web.help.projects.health_url": "Solo se usa con «Vigilar tras la fusión» activado y mientras se vigila una fusión. lastcall la consulta cada 10 minutos; cualquier respuesta con estado de 200 a 399 en menos de 10 segundos cuenta como que funciona.",
-  "web.help.projects.turns": "Las ráfagas en este proyecto se turnan: una auditoría, luego tests y luego actualizaciones de dependencias (cada una solo si está marcada), y otra vez una auditoría. «También tests» añade tests para el comportamiento que ningún test comprueba. «También dependencias» actualiza lo que necesita algo más que un número de versión nuevo: vulnerabilidades conocidas, paquetes obsoletos, versiones mayores atrasadas. Las ideas que marcaste en un plan y los issues con la etiqueta lastcall siempre van primero.",
+  "web.help.projects.turns": "Las ideas que marcaste en un plan y los issues con la etiqueta lastcall siempre van primero. Después, una ráfaga en este proyecto lo audita. Marca «También tests», «También dependencias» o las dos y las ráfagas se turnan: una auditoría, luego una ejecución que escribe tests, luego otra que actualiza dependencias (cada una solo si está marcada) y otra vez una auditoría. Una ejecución de tests abre pull requests que solo añaden tests, para el comportamiento que ningún test comprueba. Una ejecución de dependencias abre pull requests que actualizan lo que necesita algo más que un número de versión nuevo (una vulnerabilidad conocida, un paquete obsoleto, una versión mayor atrasada, un runtime que ya no tiene soporte) y arreglan el código que rompe la versión nueva; las actualizaciones menores y de parche sin más se dejan a bots como Dependabot. Los botones «Escribir tests ahora» y «Actualizar dependencias ahora» las lanzan al momento, estén marcadas o no.",
   "web.help.projects.signals": "Su nombre corto en las URLs de Sentry o GlitchTip. lastcall lee los errores sin resolver de este proyecto con un token de solo lectura: un proyecto con errores en el último día sube en la cola, y sus auditorías ven el tipo de error, el mensaje con los datos personales ocultos y las líneas de tu propio código. Los datos de la petición, del usuario y las variables locales nunca llegan a un modelo.",
   "web.help.projects.account": "«Cualquier cuenta libre» usa la cuenta que no está ejecutando nada y tiene más cuota sobrante antes de su reinicio. Elige una cuenta para usar esa.",
   "web.help.projects.account_all": "Con la opción de todas las cuentas libres, todas revisan el proyecto y la que tiene más cuota sobrante juzga los hallazgos y escribe los arreglos. Solo una auditoría puede usarlas todas: para Mejorar ahora, tests y dependencias equivale a cualquier cuenta libre.",
@@ -750,9 +788,10 @@
   "web.help.settings.language": "Se guarda en este navegador durante un año. Hasta que elijas, lastcall sigue el idioma de tu navegador. Tus notificaciones tienen su propio idioma, en Notificaciones, y lo que lastcall escribe en GitHub sigue el de cada cuenta y proyecto.",
   "web.help.settings.notify_language": "El idioma de los mensajes que te envía lastcall, sea cual sea el idioma de estas páginas. Hasta que guardes uno, lastcall toma el idioma de estas páginas al añadir tu primer destino.",
   "web.help.settings.signals_project": "En Sentry y GlitchTip, cada app envía sus errores a un proyecto con un nombre corto que aparece en sus URLs. Da ese nombre a un proyecto de lastcall en la página de proyectos: sus auditorías leerán entonces sus errores sin resolver de los últimos 14 días, los más frecuentes primero.",
-  "web.help.settings.logs_project": "La lista son los repositorios de tu página de proyectos. lastcall solo lee los logs de un contenedor cuando le das un proyecto. Si guardas «Ninguno: no se lee» en un contenedor que propuso lastcall, queda anotado tu no y esa propuesta no vuelve.",
+  "web.help.settings.logs_project": "Escribe para acotar la lista, que son los repositorios de tu página de proyectos: escribe uno como esa página, con mayúsculas o minúsculas. Cualquier otra cosa se rechaza. lastcall solo lee los logs de un contenedor, o de una fuente, cuando le das un proyecto.",
+  "web.help.settings.logs_suggested": "lastcall empareja un contenedor, o una fuente de Loki, con uno de tus proyectos por su imagen, su proyecto de Compose o su nombre, cuando solo uno encaja. No lee nada hasta que lo leas aquí. Si descartas una sugerencia queda anotado tu no y no vuelve; aun así puedes darle un proyecto más abajo, entre los demás.",
   "web.help.settings.loki_label": "Loki marca cada flujo de logs con etiquetas. lastcall lista como fuentes los valores de una etiqueta, uno por app o contenedor, vistos en los últimos 7 días. Usa la primera que tenga tu Loki de container, container_name, service_name, app y job. Elige otra solo si tus apps se llaman por otra etiqueta: tus elecciones de proyecto empiezan entonces de cero.",
-  "web.help.settings.loki_sources": "Los nombres junto a cada fuente son las máquinas donde se ejecutó, según la etiqueta host de sus logs. El proyecto de Compose, cuando Loki lo tiene, es una de las pistas que usa lastcall para proponer un proyecto; no lee nada hasta que guardes uno.",
+  "web.help.settings.loki_sources": "Los nombres junto a cada fuente son las máquinas donde se ejecutó, según la etiqueta host de sus logs. El proyecto de Compose, cuando Loki lo tiene, es una de las pistas que usa lastcall para proponer un proyecto; no lee nada hasta que elijas uno.",
   "web.help.settings.loki_tenant": "Déjalo vacío salvo que tu Loki guarde por separado los logs de varios equipos (multi-tenant) y su administrador te haya dado un nombre de tenant. lastcall lo envía en la cabecera X-Scope-OrgID de cada petición.",
   "web.help.settings.loki_token": "Con usuario, lastcall entra con ese usuario y esta contraseña (login básico). Sin usuario, lo envía como token bearer, como espera un Loki o un proxy protegido con token.",
   "web.help.settings.destination": "Cada línea es el destino tal como lo escribe Apprise, la librería que envía las notificaciones de lastcall, con sus secretos ocultos. La dirección completa se queda en el almacén de secretos de lastcall.",
@@ -792,14 +831,14 @@
   "web.project.legend.when": "Cuándo trabaja lastcall en él",
   "web.project.legend.writes": "Qué escribe y qué puede hacer",
   "web.project.active_hint": "Las ráfagas pueden elegirlo. Los botones de ejecutar funcionan igual.",
-  "web.project.merge_hint": "lastcall fusiona sus propios pull requests en cuanto los aprueban y pasan sus checks.",
-  "web.project.watch_hint": "Durante un día tras una fusión, si fallan los checks o la dirección de salud, lastcall propone una reversión y pausa el proyecto.",
+  "web.project.merge_hint": "Cuando apruebas uno de sus pull requests en GitHub, lastcall lo fusiona en cuanto pasan sus checks. Sin esto, lo fusionas tú.",
+  "web.project.watch_hint": "Durante un día tras una fusión, lastcall vigila solo los checks del commit fusionado y la dirección de salud de abajo, no tus logs ni tu tracker de errores. Si alguno falla, propone una reversión y pausa el proyecto.",
   "web.project.checks.lead": "«{merge}» y «{watch}» necesitan que la GitHub App lea los checks y los estados de commit, y esta App todavía no puede.",
   "web.project.checks.open": "Abre los permisos de la App en GitHub.",
   "web.project.checks.set": "Pon «Checks» y «Commit statuses» en «Read-only» y guarda.",
   "web.project.checks.accept": "Acepta los nuevos permisos donde GitHub te lo pida, en la instalación de la App: Settings › Applications › Installed GitHub Apps › Configure, o en los ajustes de la organización.",
-  "web.project.tests_turn": "Por turnos con las auditorías, añade tests para el comportamiento que ningún test comprueba.",
-  "web.project.deps_turn": "Por turnos con las auditorías, actualiza lo que necesita algo más que un número de versión nuevo.",
+  "web.project.tests_turn": "Algunas ráfagas escriben tests en lugar de auditar: pull requests que añaden tests para el comportamiento que ningún test comprueba.",
+  "web.project.deps_turn": "Algunas ráfagas actualizan dependencias en lugar de auditar: pull requests para lo que necesita algo más que un número de versión nuevo.",
   "web.project.run_hints": "Qué hace cada botón",
   "web.settings.events_hint": "Se aplican cuando añadas un destino arriba.",
   "web.nav.breadcrumb": "Ruta de navegación",
diff --git a/src/lastcall/logs.py b/src/lastcall/logs.py
index 7a66a9f..585a710 100644
--- a/src/lastcall/logs.py
+++ b/src/lastcall/logs.py
@@ -17,7 +17,7 @@
 
 import json
 import re
-from collections.abc import Iterable, Mapping, Sequence
+from collections.abc import Callable, Collection, Iterable, Mapping, Sequence
 from dataclasses import dataclass
 from datetime import UTC, datetime
 from typing import TYPE_CHECKING, Any
@@ -29,9 +29,13 @@
     from lastcall.store import Store
 
 LABEL = "lastcall.project"
+OWN = "lastcall"  # lastcall's own Compose project (compose.yaml): its containers are named lastcall-<service>-<n>
 CHOSEN = "container_projects"  # the owner's choices: container name -> owner/name, as JSON
 HOURS = 24
 MAX_CONTAINERS = 10  # per project
+MAX_PROJECT = (
+    140  # characters of a repository's name (owner/name) at most: what a refusal gives back of what was typed
+)
 TITLE = f"Errors in the container logs (last {HOURS} hours)"
 MAX_KINDS = 8
 MAX_FRAMES = 6
@@ -71,18 +75,134 @@ def shown(choice: str, repos: Iterable[str]) -> tuple[str, str]:
     """What the Settings page shows of the owner's choice for a container or a source: the project, as the projects
     page writes it, while it is one; or, apart, the name that the choice keeps after the owner removed the project.
     Settings keeps that choice, so that adding the project again brings it back, and the page shows none meanwhile:
-    a form that sent the removed name back as the one it showed would erase it."""
+    no form asks for it to go, and an empty field changes nothing (`apply_form`)."""
     for repo in repos:
         if repo.lower() == choice.lower():
             return repo, ""
     return "", choice
 
 
+def project_named(typed: str, repos: Iterable[str]) -> str | None:
+    """The project that `typed` names, as the Projects page writes it, whatever the case; None when it names none."""
+    wanted = typed.strip().lower()
+    return next((repo for repo in repos if repo.lower() == wanted), None)
+
+
 def project_of(container: Mapping[str, Any], choices: Mapping[str, str]) -> str:
     """The project of a container: its label, or else the owner's choice; "" for none."""
     return str(container.get("label") or "") or choices.get(str(container.get("name") or ""), "")
 
 
+def is_own(item: Mapping[str, Any]) -> bool:
+    """Whether a container, or a source in Loki, is one of lastcall's own: in its Compose project, or named
+    `lastcall-...`. The settings page never lists them: lastcall does not read its own logs."""
+    return str(item.get("compose_project") or "").lower() == OWN or str(item.get("name") or "").lower().startswith(
+        OWN + "-"
+    )
+
+
+@dataclass(frozen=True)
+class Parts:
+    """The containers of a host, or the sources of a Loki, in the three parts that the settings page shows."""
+
+    read: list[dict[str, Any]]  # lastcall reads them: by their label, or by the owner's choice of a project
+    suggested: list[dict[str, Any]]  # lastcall found a project for them, which the owner has not chosen yet
+    others: list[dict[str, Any]]  # the rest: no project fits, the owner said no, or the chosen project is gone
+
+    @property
+    def count(self) -> int:
+        return len(self.read) + len(self.suggested) + len(self.others)
+
+    def others_named(self, query: str) -> list[dict[str, Any]]:
+        """The others whose name contains `query`, whatever the case; all of them for an empty one."""
+        wanted = query.casefold()
+        return [o for o in self.others if wanted in str(o["name"]).casefold()]
+
+
+def parts(listed: Iterable[Mapping[str, Any]], repos: Sequence[str], choices: Mapping[str, str]) -> Parts:
+    """Sort what is listed into read, suggested and the rest, never lastcall's own. A read one has `project`, as the
+    Projects page writes it, and `by` ("label" or "choice"); a label names a project that may not exist (`unknown`).
+    The others carry `suggested` and `gone` (see `shown`). A label wins over a choice, and a suggestion is no choice:
+    nothing is read until the owner chooses it."""
+    read: list[dict[str, Any]] = []
+    suggested: list[dict[str, Any]] = []
+    others: list[dict[str, Any]] = []
+    for item in listed:
+        if is_own(item):
+            continue
+        name, label = str(item.get("name") or ""), str(item.get("label") or "")
+        choice, gone = shown(choices.get(name, ""), repos)
+        if label:
+            project, unnamed = shown(label, repos)
+            read.append({**item, "project": project or unnamed, "by": "label", "unknown": not project})
+        elif choice:
+            read.append({**item, "project": choice, "by": "choice"})
+        else:
+            hint = "" if name in choices else suggest(item, repos)
+            (suggested if hint else others).append({**item, "suggested": hint, "gone": gone})
+    return Parts(read, suggested, others)
+
+
+class Refused(ValueError):
+    """What the settings page's forms send is not acceptable. `reason` is "form" (a form that the page never sends),
+    "none" (a button for the ticked ones, with none ticked) or "project" (a project that is not one: `typed` has what
+    the owner wrote next to each container, `wrong` the first name that is not a project). The text that it gives
+    back is cut at the length of a repository's name: nothing longer is a project, and the page shows it again."""
+
+    def __init__(self, reason: str, typed: Mapping[str, str] | None = None, wrong: str = "") -> None:
+        super().__init__(reason)
+        self.reason, self.wrong = reason, wrong[:MAX_PROJECT]
+        self.typed = {name: text[:MAX_PROJECT] for name, text in (typed or {}).items()}
+
+
+def apply_form(
+    form: Mapping[str, str],
+    ticked: Collection[str],
+    choices: Mapping[str, str],
+    repos: Sequence[str],
+    valid: Callable[[str], bool],
+) -> dict[str, str]:
+    """The owner's choices after one of the settings page's forms, for containers or for sources in Loki. Each row
+    of a form is `name-N`, and, for a project, `project-N`; `pick` says what the button asks for:
+
+    - `selected`, `suggested`: read the rows that are ticked (`ticked` holds their N), or all of them, for the project
+      that the page showed in `project-N`;
+    - `skip`: say no to the ticked rows, so that they are not suggested again;
+    - `stop`: say no to the rows, which were read;
+    - anything else: the rows with a project typed in `project-N`. An empty one changes nothing, so that saving never
+      erases a choice that the page shows apart (a project that was removed).
+
+    A project is checked against `repos`, whatever the case, and written as the Projects page writes it. Nothing is
+    changed unless every row is acceptable: `Refused` says why."""
+    rows = []
+    for key, name in form.items():
+        if key.startswith("name-"):
+            if not valid(name):
+                raise Refused("form")
+            rows.append((key.removeprefix("name-"), name))
+    pick, chosen = form.get("pick", ""), dict(choices)
+    if pick in ("selected", "suggested", "skip", "stop"):
+        picked = [(n, name) for n, name in rows if pick in ("suggested", "stop") or n in ticked]
+        if not picked:
+            raise Refused("none")
+        for n, name in picked:
+            if pick in ("skip", "stop"):
+                chosen[name] = ""
+                continue
+            project = project_named(form.get("project-" + n, ""), repos)
+            if project is None:  # the page showed a project for each suggestion: a form that says another is forged
+                raise Refused("form")
+            chosen[name] = project
+        return chosen
+    typed = {name: text for n, name in rows if (text := form.get("project-" + n, "").strip())}
+    for name, text in typed.items():
+        project = project_named(text, repos)
+        if project is None:
+            raise Refused("project", typed, text)
+        chosen[name] = project
+    return chosen
+
+
 def names_for(repo: str, listed: Iterable[Mapping[str, Any]], choices: Mapping[str, str]) -> list[str]:
     """The containers of a project, by name."""
     return [str(c["name"]) for c in listed if project_of(c, choices).lower() == repo.lower()][:MAX_CONTAINERS]
diff --git a/src/lastcall/tiers.py b/src/lastcall/tiers.py
index 181e128..299e19d 100644
--- a/src/lastcall/tiers.py
+++ b/src/lastcall/tiers.py
@@ -8,19 +8,31 @@
 
 Tier = Literal["fast", "balanced", "deep"]
 TIERS: tuple[Tier, ...] = ("fast", "balanced", "deep")
+SECTIONS = ("_about", "models", "efforts")  # the keys of tiers.json that are not an engine's tiers
 
 
 def defaults(engine: str) -> dict[str, tuple[str, str | None]]:
     """tier -> (model, effort), from lastcall/data/tiers.json."""
     data = _data()
-    if engine not in data or engine == "efforts":
+    if engine not in data or engine in SECTIONS:
         raise ValueError(f"no default tiers for engine {engine!r}")
     return {tier: (str(model), str(effort) if effort else None) for tier, (model, effort) in data[engine].items()}
 
 
+def models(engine: str) -> tuple[str, ...]:
+    """The model names that an engine's CLI takes, which the web UI suggests for a tier's model; none for an engine
+    with no list (an API key's models come from models.dev, `lastcall.catalog`)."""
+    return _listed("models", engine)
+
+
 def efforts(engine: str) -> tuple[str, ...]:
     """The effort levels that an engine's CLI takes, the lowest first; none for an engine that takes none."""
-    return tuple(str(level) for level in _data()["efforts"].get(engine, ()))
+    return _listed("efforts", engine)
+
+
+def _listed(section: str, engine: str) -> tuple[str, ...]:
+    names = _data()[section].get(engine, ()) if engine != "_about" else ()
+    return tuple(str(name) for name in names)
 
 
 def _data() -> dict[str, Any]:
diff --git a/src/lastcall/web/__init__.py b/src/lastcall/web/__init__.py
index eeb34f5..0cf8eea 100644
--- a/src/lastcall/web/__init__.py
+++ b/src/lastcall/web/__init__.py
@@ -32,7 +32,7 @@
 from flask.typing import ResponseReturnValue
 from werkzeug.middleware.proxy_fix import ProxyFix
 
-from lastcall import __version__, cron, destinations, engines, i18n, logs, loki, projects, signals
+from lastcall import __version__, catalog, cron, destinations, engines, i18n, logs, loki, projects, signals
 from lastcall.accounts import ACCOUNT_ID, MODEL, Account, policies, tier_models
 from lastcall.engines.base import Keyed
 from lastcall.github import PERMISSIONS, App, Fetch, GitHub, GitHubError, lacking, permissions_of, urlopen
@@ -45,6 +45,7 @@
 from lastcall.store import AccountRow, Store
 from lastcall.supervisor import STEP
 from lastcall.tiers import TIERS, defaults, efforts
+from lastcall.tiers import models as cli_models
 from lastcall.web import auth, dashboard, project_views
 
 COOKIE = "lastcall_session"
@@ -66,6 +67,10 @@
 RETRY_SECONDS = 60.0  # a gap (the owner is fixing it) or a miss is kept only a minute, so that the notice goes soon
 GRANT_TIMEOUT = 5  # seconds that the Projects page waits for GitHub's answer on one installation
 MAX_GRANTS = 100
+CATALOG_SECONDS = 86_400.0  # the models that models.dev lists for an API's provider, kept a day: they weigh 6 MB
+CATALOG_RETRY_SECONDS = 600.0  # a miss is kept 10 minutes, so that a models.dev that is down costs one wait
+CATALOG_TIMEOUT = 5  # seconds that the Accounts page waits for models.dev
+KEYS_LIST = "models-keys"  # the datalist of the form that adds an API key: the models of every provider
 MAX_ADDED = 100_000  # the most that a "N projects added" notice says: the number is in the address
 CREDENTIAL = re.compile(r"(?i)\b(bearer|basic)\s+[^\"']*|\b(authorization|header value)\W+.*")
 QUICKSTART = "https://github.com/ne0x86/lastcall#-quickstart"
@@ -109,8 +114,9 @@ def create_app(
     """The web UI's application. `github` gives the GitHub client (by default, from the App in the secret store);
     `background` runs slow work, such as reading the installed repositories, outside the request. `read_quota`
     reads an account's quota in the sandbox; without it, the web UI cannot check a new account's login.
-    `exchange` turns GitHub's one-time code into the App's credentials; `fetch` asks Telegram for a bot's chats, and
-    GitHub whether an owner is a person or an organization, and what the App's installation was granted."""
+    `exchange` turns GitHub's one-time code into the App's credentials; `fetch` asks Telegram for a bot's chats,
+    GitHub whether an owner is a person or an organization, and what the App's installation was granted, and
+    models.dev which models an API key's provider offers."""
     app = Flask(__name__)
     app.config["MAX_CONTENT_LENGTH"] = 64 * 1024  # forms are small
     if trust_proxy:
@@ -125,7 +131,8 @@ def create_app(
     app_states: dict[str, float] = {}  # manifest forms shown, by state, with when they were shown
     owner_answers: dict[str, tuple[str, float]] = {}  # what GitHub said an owner is ("user", "org", "missing"), when
     grant_answers: dict[str, tuple[str | None, float]] = {}  # permissions_page of an owner's installation, and when
-    cache_lock = threading.Lock()  # for app_states, owner_answers and grant_answers: waitress answers on 8 threads
+    catalog_answers: dict[str, tuple[tuple[str, ...], float]] = {}  # a provider's models in models.dev, until when
+    cache_lock = threading.Lock()  # for the four above: waitress answers on 8 threads
     quota_errors: dict[str, tuple[float, str]] = {}  # the last failed quota reading of each account, and when
 
     def connect() -> GitHub | None:
@@ -280,13 +287,30 @@ def service(action: str) -> ResponseReturnValue:
     @app.get("/projects")
     @signed_in
     def projects_page() -> ResponseReturnValue:
-        return show_projects(query=request.args.get("q", ""))
+        args = request.args
+        return show_projects(query=args.get("q", ""), search=args.get("search", ""), show=args.get("show", "all"))
 
-    def show_projects(status: int = 200, error: str = "", install: str = "", query: str = "") -> ResponseReturnValue:
-        """The Projects page. `query` is what its filter looks for in the suggestions' names."""
+    def show_projects(
+        status: int = 200,
+        error: str = "",
+        install: str = "",
+        query: str = "",
+        search: str = "",
+        show: str = "all",
+    ) -> ResponseReturnValue:
+        """The Projects page. `query` is what its filter looks for in the suggestions' names; `search` and `show` are
+        what the owner looks for in the projects' names, and which filter of the cards (project_views.FILTERS)."""
         found = App.load(secrets)
         view = project_views.build(
-            store, g.lang, clock(), found.install_url if found else "", reading.is_set(), permissions_link, query
+            store,
+            g.lang,
+            clock(),
+            found.install_url if found else "",
+            reading.is_set(),
+            permissions_link,
+            query,
+            search,
+            show,
         )
         view.tracker = signals.Tracker.load(secrets) is not None
         done = request.args.get("done", "")
@@ -341,6 +365,32 @@ def permissions_link(repo: str) -> str:
                 del grant_answers[next(iter(grant_answers))]
         return found or ""
 
+    def catalog_models(provider: str) -> tuple[str, ...]:
+        """The models that models.dev lists for a provider of API keys (its id there), from the last day when it was
+        asked: the Accounts page asks on every load, and the answer weighs 6 MB. One request answers for every
+        provider. A failure is kept 10 minutes, so that a models.dev that is down costs the page one wait in that
+        time, not one at every load; meanwhile it suggests no models. Bounded: one entry for each provider that an
+        engine offers, and `catalog.MAX_MODELS` models in each."""
+        asked = catalog_providers()
+        if provider not in asked:
+            return ()
+        now = clock()
+        with cache_lock:
+            known = catalog_answers.get(provider)
+        if known is not None and now < known[1]:
+            return known[0]
+        try:
+            found = catalog.models(fetch, asked, CATALOG_TIMEOUT)
+            until = now + CATALOG_SECONDS
+        except Exception as e:  # an optional lookup never takes the page down
+            log(f"Web UI: models.dev gave no models: {brief(e)}")
+            found, until = {}, now + CATALOG_RETRY_SECONDS
+        with cache_lock:
+            for name in asked:
+                catalog_answers.pop(name, None)  # asked again: it goes to the end, as the newest
+                catalog_answers[name] = (found.get(name, ()), until)
+        return found.get(provider, ())
+
     @app.post("/projects/add")
     @signed_in
     def add_project() -> ResponseReturnValue:
@@ -548,8 +598,16 @@ def show_settings(
         tried: Mapping[str, str] | None = None,
         loki_error: str = "",
         loki_tried: Mapping[str, str] | None = None,
+        logs_error: str = "",
+        logs_typed: Mapping[str, str] | None = None,
+        loki_typed: Mapping[str, str] | None = None,
     ) -> ResponseReturnValue:
+        """The Settings page. A mistake in one of the forms of the lists of containers or sources says it in that
+        section (`logs_error`, `loki_error`) and gives back the projects that the owner typed there (`logs_typed`,
+        `loki_typed`). The filters by name of the two lists are in the address (`logs_q`, `loki_q`)."""
         chosen, filled = notifications.events(), dict(values or {})
+        logs_q = project_views.clean_query(request.args.get("logs_q", ""))
+        loki_q = project_views.clean_query(request.args.get("loki_q", ""))
         language = (
             notifications.language() if store.setting("notify_language") else g.lang
         )  # until saved: this page's
@@ -572,8 +630,8 @@ def show_settings(
             "chats": list(chats),
             "fanout": store.setting("fanout") == "yes",
             "tracker": tracker,
-            "logs": containers_view(),
-            "loki": loki_view(loki_tried),
+            "logs": containers_view(logs_q, logs_typed),
+            "loki": loki_view(loki_tried, loki_q, loki_typed),
             "signals_url": (tried or {}).get("url") or (tracker.url if tracker else "https://sentry.io"),
             "signals_org": (tried or {}).get("org") or (tracker.org if tracker else ""),
         }
@@ -595,6 +653,7 @@ def show_settings(
             signals_error=signals_error,
             sentry_tokens=SENTRY_TOKENS,
             loki_error=loki_error,
+            logs_error=logs_error,
         )
 
     @app.post("/settings/signals")
@@ -619,44 +678,56 @@ def connect_signals() -> ResponseReturnValue:
         log(f"Web UI: errors in production read from {url}, organization {org}")
         return redirect(url_for("settings_page", done="signals") + "#signals")
 
+    def refusal(refused: logs.Refused, kind: str) -> ResponseReturnValue:
+        """The answer to a form of a list of containers (`kind` "logs") or of sources in Loki ("loki") that
+        `logs.apply_form` refuses: an error page for a form that the page never sends, else the Settings page, with
+        the mistake said in the section and what the owner typed in its place."""
+        if refused.reason == "form":
+            return problem(400, "web.error.form")
+        if refused.reason == "none":
+            message = t(f"web.{kind}.none_ticked")
+        else:
+            message = t("web.logs.not_a_project", project=refused.wrong)
+        if kind == "logs":
+            return show_settings(400, logs_error=message, logs_typed=refused.typed)
+        return show_settings(400, loki_error=message, loki_typed=refused.typed)
+
     @app.post("/settings/logs")
     @signed_in
     def logs_settings() -> ResponseReturnValue:
-        """The project of each container, as the owner chooses it: lastcall reads the containers that have one."""
-        form, repos = request.form, {p.repo for p in store.projects()}
-        choices = logs.chosen(store)
-        for key, name in form.items():
-            if not key.startswith("name-"):
-                continue
-            index = key.removeprefix("name-")
-            project = form.get("project-" + index, "")
-            if not CONTAINER.fullmatch(name) or project not in {"", *repos}:
-                return problem(400, "web.error.form")
-            if project or form.get("shown-" + index):  # a project, or a no to the one that the page showed
-                choices[name] = project
+        """What the forms of the Container logs section ask (`logs.apply_form`): to read the ticked suggestions, or
+        all of them, to skip the ticked ones, to stop reading one, or to read the containers that got a project in
+        the fold of the others. The project of each is checked against the projects, whatever its case."""
+        form = request.form
+        try:
+            choices = logs.apply_form(
+                form,
+                form.getlist("tick"),
+                logs.chosen(store),
+                [p.repo for p in store.projects()],
+                lambda name: bool(CONTAINER.fullmatch(name)) and not name.startswith(STEP),  # never a step's
+            )
+        except logs.Refused as refused:
+            return refusal(refused, "logs")
         logs.choose(store, choices)
         log(f"Web UI: containers read for their projects: {', '.join(sorted(k for k, v in choices.items() if v))}")
         return redirect(url_for("settings_page", done="logs") + "#logs")
 
-    def containers_view() -> dict[str, Any]:
-        """The containers of this host, each with its project, or the one lastcall suggests."""
+    def containers_view(query: str = "", typed: Mapping[str, str] | None = None) -> dict[str, Any]:
+        """The containers of this host in the three parts that the page shows (`logs.parts`)."""
         if containers is None:
-            return {"error": t("web.logs.unavailable"), "rows": [], "repos": []}
+            return {**lists_view(logs.Parts([], [], []), [], query, {}), "error": t("web.logs.unavailable")}
         try:
             listed = containers()
         except Exception as e:  # an optional integration never takes the page down
             known = isinstance(e, (SandboxError, OSError))
             if not known:
                 log(f"Web UI: the containers could not be listed: {brief(e)}")
-            return {"error": t("web.logs.failed", error=str(e)[:200] if known else brief(e)), "rows": [], "repos": []}
-        repos, choices = [p.repo for p in store.projects()], logs.chosen(store)
-        rows = []
-        for c in listed:
-            name = str(c.get("name") or "")
-            choice, gone = logs.shown(choices.get(name, ""), repos)
-            hint = "" if c.get("label") or name in choices else logs.suggest(c, repos)
-            rows.append({**c, "selected": choice or hint, "suggested": hint, "gone": gone})
-        return {"error": "", "rows": rows, "repos": repos}
+            failed = t("web.logs.failed", error=str(e)[:200] if known else brief(e))
+            return {**lists_view(logs.Parts([], [], []), [], query, {}), "error": failed}
+        repos = [p.repo for p in store.projects()]
+        found = logs.parts(listed, repos, logs.chosen(store))
+        return {**lists_view(found, repos, query, typed or {}), "error": ""}
 
     @app.post("/settings/loki")
     @signed_in
@@ -697,21 +768,22 @@ def loki_label() -> ResponseReturnValue:
     @app.post("/settings/loki/sources")
     @signed_in
     def loki_sources() -> ResponseReturnValue:
-        """The project of each source in Loki, as the owner chooses it: lastcall reads the sources that have one."""
-        form, repos = request.form, {p.repo for p in store.projects()}
+        """What the forms of the sources in Loki ask, as the containers' do (`logs_settings`): lastcall reads the
+        sources that have a project. Each form says the label that names the sources: the choices belong to it."""
+        form = request.form
         label = form.get("label", "")
         if not loki.LABEL_NAME.fullmatch(label):
             return problem(400, "web.error.form")
-        choices = loki.chosen(store) if label == store.setting(loki.LABEL) else {}
-        for key, name in form.items():
-            if not key.startswith("name-"):
-                continue
-            index = key.removeprefix("name-")
-            project = form.get("project-" + index, "")
-            if not loki.SOURCE.fullmatch(name) or name.startswith(STEP) or project not in {"", *repos}:
-                return problem(400, "web.error.form")
-            if project or form.get("shown-" + index):  # a project, or a no to the one that the page showed
-                choices[name] = project
+        try:
+            choices = logs.apply_form(
+                form,
+                form.getlist("tick"),
+                loki.chosen(store) if label == store.setting(loki.LABEL) else {},
+                [p.repo for p in store.projects()],
+                lambda name: bool(loki.SOURCE.fullmatch(name)) and not name.startswith(STEP),
+            )
+        except logs.Refused as refused:
+            return refusal(refused, "loki")
         store.set_setting(loki.LABEL, label)
         loki.choose(store, choices)
         read = ", ".join(sorted(k for k, v in choices.items() if v))
@@ -725,15 +797,18 @@ def disconnect_loki() -> ResponseReturnValue:
         log("Web UI: Loki disconnected")
         return redirect(url_for("settings_page", done="loki_removed") + "#loki")
 
-    def loki_view(tried: Mapping[str, str] | None) -> dict[str, Any]:
-        """The connection to Loki, and its sources, each with its project, or the one lastcall suggests."""
+    def loki_view(
+        tried: Mapping[str, str] | None, query: str = "", typed: Mapping[str, str] | None = None
+    ) -> dict[str, Any]:
+        """The connection to Loki, and its sources in the three parts that the page shows (`logs.parts`)."""
         connection, tried = loki.Loki.load(secrets), tried or {}
         view: dict[str, Any] = {
             "connection": connection,
             "url": tried.get("url") or (connection.url if connection else ""),
             "user": tried.get("user") or (connection.user if connection else ""),
             "tenant": tried.get("tenant") or (connection.tenant if connection else ""),
-            **{"error": "", "labels": [], "label": "", "rows": [], "repos": []},
+            **lists_view(logs.Parts([], [], []), [], query, {}),
+            **{"error": "", "labels": [], "label": ""},
         }
         if connection is None:
             return view
@@ -747,13 +822,8 @@ def loki_view(tried: Mapping[str, str] | None) -> dict[str, Any]:
             if not known:
                 log(f"Web UI: Loki's sources could not be listed: {brief(e)}")
             return {**view, "error": t("web.loki.sources_failed", error=str(e)[:200] if known else brief(e))}
-        rows = []
-        for s in listed:
-            name = s["name"]
-            choice, gone = logs.shown(choices.get(name, ""), repos)
-            hint = "" if name in choices else logs.suggest(s, repos)
-            rows.append({**s, "selected": choice or hint, "suggested": hint, "gone": gone})
-        return {**view, "labels": names, "label": label, "rows": rows, "repos": repos}
+        found = logs.parts(listed, repos, choices)
+        return {**view, **lists_view(found, repos, query, typed or {}), "labels": names, "label": label}
 
     @app.post("/settings/signals/remove")
     @signed_in
@@ -951,13 +1021,23 @@ def show_accounts(
         message = t(f"web.done.{done}") if done in known and not error else ""
         all_engines = [engines.get(name) for name in sorted(engines.BUILTIN)]
         sources = [(e, p) for e in all_engines if isinstance(e, Keyed) for p in e.providers]
+        lists: dict[str, tuple[str, ...]] = {}  # the datalists of the page, by id: what its model fields suggest
+        cards = [account_card(row, now, working, lists) for row in store.accounts()]
+        keys = [(f"{e.name}/{p.name}", p) for e, p in sources if p.keys]
+        # Without a script, the form that adds an API key cannot follow the provider that it has chosen: its model
+        # fields suggest the models of every provider, and OpenRouter writes the maker first (qwen/qwen3-coder).
+        everyone = {name for _, p in keys for name in catalog_models(p.catalog)}
+        if everyone:
+            lists[KEYS_LIST] = tuple(sorted(everyone, key=lambda name: (name.casefold(), name)))
         return page(
             "accounts.html",
             status,
-            cards=[account_card(row, now, working) for row in store.accounts()],
+            cards=cards,
             held="down" if down else ("paused" if paused else ""),
             engines=[(e.name, f"{e.provider} ({e.title})") for e in all_engines if e.login],
-            keys=[(f"{e.name}/{p.name}", p) for e, p in sources if p.keys],
+            keys=keys,
+            datalists=lists,
+            key_list=KEYS_LIST if everyone else "",
             local=next(((f"{e.name}/{p.name}", p) for e, p in sources if not p.keys), None),
             writing=[(name, dashboard.language_name(g.lang, name).capitalize()) for name in project_views.LANGUAGES],
             known=project_views.LANGUAGES,
@@ -993,7 +1073,32 @@ def quota_error(account_id: str) -> str:
             return ""
         return failed[1]
 
-    def account_card(row: AccountRow, now: float, working: Mapping[str, dict[str, Any]]) -> dict[str, Any]:
+    def suggestions(row: AccountRow, lists: dict[str, tuple[str, ...]]) -> dict[str, str]:
+        """The datalist that suggests models in the fields of an account's tiers, and the note that says where its
+        names come from: for an account on a CLI login, the names that the CLI takes, from lastcall's data file; for
+        an account on an API key, what models.dev lists for its provider. Empty when there is nothing to suggest: a
+        local model server (the web UI cannot reach it), a models.dev that did not answer, an engine that is gone."""
+        if row.engine not in engines.BUILTIN:
+            return {}
+        engine = engines.get(row.engine)
+        if not row.keyed:
+            names, key, note = cli_models(row.engine), row.engine, t("web.tiers.suggest.cli", tool=engine.title)
+        elif isinstance(engine, Keyed):
+            source = next((p for p in engine.providers if p.name == row.provider), None)
+            if source is None:
+                return {}
+            names, key = catalog_models(source.catalog), f"{row.engine}-{source.name}"
+            note = t("web.tiers.suggest.catalog", provider=source.title)
+        else:
+            return {}
+        if not names:
+            return {}
+        lists[f"models-{key}"] = names
+        return {"list": f"models-{key}", "note": note}
+
+    def account_card(
+        row: AccountRow, now: float, working: Mapping[str, dict[str, Any]], lists: dict[str, tuple[str, ...]]
+    ) -> dict[str, Any]:
         try:
             base = defaults(row.engine)
         except ValueError:  # an engine with no defaults, such as opencode: the account names its models
@@ -1008,6 +1113,7 @@ def account_card(row: AccountRow, now: float, working: Mapping[str, dict[str, An
             "policies": [],
             "needs_key": False,
             "levels": efforts(row.engine),
+            "suggest": suggestions(row, lists),
             "tiers": [
                 {
                     "tier": tier,
@@ -1236,6 +1342,16 @@ def not_found(_: Exception) -> ResponseReturnValue:
     return app
 
 
+def catalog_providers() -> tuple[str, ...]:
+    """The ids in models.dev of the providers that the engines on API keys offer: what the web UI asks it about."""
+    found: list[str] = []
+    for name in sorted(engines.BUILTIN):
+        engine = engines.get(name)
+        if isinstance(engine, Keyed):
+            found += [p.catalog for p in engine.providers if p.catalog]
+    return tuple(dict.fromkeys(found))
+
+
 def brief(error: BaseException) -> str:
     """An exception for the log: its type and a short line of its message. Never its repr, which can hold request
     data, and a header's value or an authorization is masked wherever it shows in the message."""
@@ -1243,6 +1359,25 @@ def brief(error: BaseException) -> str:
     return f"{type(error).__name__}: {message[:120]}" if message else type(error).__name__
 
 
+def lists_view(found: logs.Parts, repos: Sequence[str], query: str, typed: Mapping[str, str]) -> dict[str, Any]:
+    """What the template needs of a list of containers or sources in three parts: those that are read, those that
+    are suggested, and the others that the filter by name leaves, each with what the owner typed next to it before a
+    mistake in the form. The fold of the others says how many there are in all (`total`) and offers the filter once
+    there are many of them or while one is set."""
+    others = [{**o, "typed": typed.get(str(o["name"]), "")} for o in found.others_named(query)]
+    return {
+        "read": found.read,
+        "suggested": found.suggested,
+        "others": others,
+        "total": len(found.others),
+        "count": found.count,
+        "query": query,
+        "typed": bool(typed),
+        "filterable": len(found.others) > project_views.MANY or bool(query),
+        "repos": list(repos),
+    }
+
+
 def language() -> str:
     chosen = request.cookies.get(LANGUAGE_COOKIE, "")
     if chosen in i18n.CATALOGS:
diff --git a/src/lastcall/web/project_views.py b/src/lastcall/web/project_views.py
index af128bc..b2b6630 100644
--- a/src/lastcall/web/project_views.py
+++ b/src/lastcall/web/project_views.py
@@ -17,6 +17,9 @@
 LANGUAGES = ("English", "Spanish")
 MAX_PRS = range(1, 6)
 MAX_QUERY = 100  # characters of what the filter of the suggestions looks for: a repository's name has 140 at most
+MANY = 6  # with more than this, lists get a filter by name (the suggestions, the projects, the settings' lists) and a
+# project's Run now starts folded
+FILTERS = ("all", "active", "inactive", "waiting")  # what the filter links of the cards show
 # what a project's card says while an order of each recipe waits, or while a run of it works
 QUEUED = {
     "audit": "web.project.queued",
@@ -81,12 +84,20 @@ class SuggestionView:
     left_out: bool = False  # archived, a fork or empty: "Add all" skips it
 
 
+@dataclass(frozen=True)
+class FilterLink:
+    key: str  # one of FILTERS
+    label: str
+    count: int  # the projects that it shows, for the current search
+    current: bool
+
+
 @dataclass
 class ProjectsPage:
     github_ready: bool
     install_url: str
     refreshed: str
-    projects: list[ProjectCard] = field(default_factory=list)
+    projects: list[ProjectCard] = field(default_factory=list)  # what the search and the filter leave
     accounts: list[Option] = field(default_factory=list)
     suggested: list[SuggestionView] = field(default_factory=list)  # what the filter shows
     others: list[SuggestionView] = field(default_factory=list)
@@ -94,6 +105,20 @@ class ProjectsPage:
     tracker: bool = False  # the owner connected an error tracker: each project may name its project there
     query: str = ""  # what the filter looks for in their names; "" for no filter
     total: int = 0  # the repositories that are not projects yet, before the filter
+    known: int = 0  # how many projects there are, whatever the search and the filter
+    search: str = ""  # what the search looks for in the names of the projects; "" for none
+    show: str = "all"  # the filter of the cards: one of FILTERS
+    filters: list[FilterLink] = field(default_factory=list)
+
+    @property
+    def many(self) -> bool:
+        """Whether there are so many projects that each card starts with its Run now folded."""
+        return self.known > MANY
+
+    @property
+    def can_search(self) -> bool:
+        """Whether the page offers the search and the filters: with many projects, or while one of them is set."""
+        return self.many or bool(self.search) or self.show != "all"
 
     @property
     def has_all(self) -> bool:
@@ -119,15 +144,26 @@ def build(
     reading: bool,
     permissions_url: Callable[[str], str],
     query: str = "",
+    search: str = "",
+    show: str = "all",
 ) -> ProjectsPage:
     """`permissions_url` says, for a repository, where its owner gives the App what reading checks takes: "" when the
-    App has it already, or when that is not known. It is asked only for the projects that read checks. `query` is
-    what the filter looks for in the names of the suggestions."""
+    App has it already, or when that is not known. It is asked only for the cards that show, and for the projects that
+    read checks. `query` is what the filter looks for in the names of the suggestions; `search` and `show` are what
+    the owner looks for in the names of the projects, and which of FILTERS to show."""
     projects = store.projects()
     busy = {o["repo"].lower(): text(lang, QUEUED.get(o["kind"], QUEUED["audit"])) for o in store.orders()}
     busy |= {r["repo"].lower(): text(lang, RUNNING.get(r["recipe"], RUNNING["audit"])) for r in store.running()}
     latest = store.latest_runs()
     page = ProjectsPage(bool(install_url), install_url, refreshed(store, lang, now, reading))
+    search, show = clean_query(search), clean_show(show)
+    page.known, page.search, page.show = len(projects), search, show
+    waiting = waiting_for_the_owner(store)
+    named = [p for p in projects if search.casefold() in p.repo.casefold()]
+    counts = {key: sum(passes(key, p, waiting) for p in named) for key in FILTERS}
+    page.filters = [
+        FilterLink(key, text(lang, f"web.projects.filter.{key}"), counts[key], key == show) for key in FILTERS
+    ]
     page.projects = [
         card(
             store,
@@ -138,7 +174,8 @@ def build(
             busy.get(p.repo.lower(), ""),
             permissions_url(p.repo) if p.merge_on_approve or p.watch else "",
         )
-        for p in projects
+        for p in named
+        if passes(show, p, waiting)
     ]
     enabled = store.accounts(enabled_only=True)
     page.accounts = [Option("", text(lang, "web.project.any"), True)]
@@ -163,10 +200,39 @@ def left_to_add(projects: Iterable[ProjectRow], found: Iterable[Suggestion]) ->
 
 
 def clean_query(typed: str) -> str:
-    """What the filter of the suggestions looks for: the text without the spaces around it, cut at 100 characters."""
+    """What a filter or a search looks for: the text without the spaces around it, cut at 100 characters."""
     return typed.strip()[:MAX_QUERY]
 
 
+def clean_show(typed: str) -> str:
+    """The filter of the cards that an address asks for: one of FILTERS, and "all" for any other value."""
+    return typed if typed in FILTERS else "all"
+
+
+def is_active(p: ProjectRow) -> bool:
+    """Whether bursts may pick the project: its flag is on and it has a priority (a weight of 0 or less is off)."""
+    return p.active and p.weight > 0
+
+
+def waiting_for_the_owner(store: Store) -> set[str]:
+    """The projects, in lower case, that wait for the owner: they have pull requests to review, decisions in an issue,
+    or ideas to choose in a plan, as the dashboard lists them under Waiting for you."""
+    found = {pr["repo"] for pr in store.open_prs()} | {d["repo"] for d in store.decisions()}
+    return {repo.lower() for repo in found | {plan["repo"] for plan in store.plans()}}
+
+
+def passes(show: str, p: ProjectRow, waiting: set[str]) -> bool:
+    """Whether the filter `show` leaves the project."""
+    match show:
+        case "active":
+            return is_active(p)
+        case "inactive":
+            return not is_active(p)
+        case "waiting":
+            return p.repo.lower() in waiting
+    return True
+
+
 def addable(found: Iterable[Suggestion]) -> list[Suggestion]:
     """What "Add all" adds of these suggestions: not the archived ones, the forks or the empty ones."""
     return [s for s in found if not s.left_out]
@@ -181,7 +247,7 @@ def matching(found: Iterable[Suggestion], query: str) -> list[Suggestion]:
 def card(
     store: Store, p: ProjectRow, lang: str, now: float, last: dict[str, Any] | None, busy: str, permissions_url: str
 ) -> ProjectCard:
-    active = p.active and p.weight > 0
+    active = is_active(p)
     view = project_view(store, p.repo, active, p.weight, lang, now, last)
     waiting = store.waiting_count(p.repo)
     weights = [Option(v, text(lang, f"web.project.weight.{k}"), float(v) == p.weight) for v, k in WEIGHTS]
diff --git a/src/lastcall/web/static/style.css b/src/lastcall/web/static/style.css
index c462e13..4253cb8 100644
--- a/src/lastcall/web/static/style.css
+++ b/src/lastcall/web/static/style.css
@@ -913,7 +913,32 @@ ul.rows > li:last-child { border-bottom: 0; }
 .row-actions { display: flex; flex-wrap: wrap; gap: var(--s2); }
 .row-actions form { margin: 0; }
 .source-name { display: flex; flex-wrap: wrap; align-items: center; gap: var(--s2); margin: 0; }
-.sources select { margin-top: var(--s1); }
+.source-name strong { overflow-wrap: anywhere; }
+
+/* A long list of containers or sources in three parts: what is read comes first, as short rows with a way to stop it; the
+   suggestions are the Projects page's tiles (ul.suggestions); the rest is a fold with a filter by name and, for each one,
+   a field whose datalist narrows the projects as you type. */
+.parts { display: grid; gap: var(--s4); margin: var(--s3) 0; }
+.part-title { margin: 0 0 var(--s2); font-family: var(--font-round); font-size: 1.02rem; font-weight: 700; }
+.part > .section-head .part-title { margin: 0; }
+.part > p { margin: 0; }
+ul.reading { margin: 0; }
+ul.reading > li { display: flex; flex-wrap: wrap; align-items: center; justify-content: space-between; gap: var(--s2) var(--s3); }
+.read-main { flex: 1 1 9rem; min-width: 0; }
+.read-main p { margin: 0; }
+.read-main .hint { margin-top: var(--s1); }
+.read-project { overflow-wrap: anywhere; }
+.reading .row-actions { flex: none; }
+.others-fold { margin: 0; }
+.others-form { display: grid; gap: var(--s3); margin: 0; }
+.others-form > button { justify-self: start; }
+ul.others { margin: 0; }
+ul.others > li { grid-template-columns: minmax(0, 1fr); align-items: start; }
+.other-main > p { margin: 0; }
+.other-main > .hint { margin-top: var(--s1); }
+@media (min-width: 48rem) {
+  ul.others > li { grid-template-columns: minmax(0, 1fr) minmax(14rem, 20rem); align-items: center; gap: var(--s1) var(--s3); }
+}
 
 /* ---------- Settings ---------- */
 .settings-layout { display: grid; gap: var(--s4); }
@@ -1111,6 +1136,7 @@ fieldset.has-help > legend { float: left; margin: 0; }
 .project-settings fieldset { gap: var(--s3); padding: var(--s3); background: var(--surface); border-radius: var(--r-md); }
 .project-settings .check-row { min-height: 0; }
 .project-settings .check-row .hint { margin-top: 0; }
+.project-settings .fields { grid-template-columns: minmax(0, 1fr); }  /* a select a row: a closed select cuts its text short */
 
 /* Add a project: the manual field, then suggestions as rows. */
 .add-card .inline { margin-bottom: var(--s2); }
@@ -1173,6 +1199,43 @@ ul.suggestions li:has(input:checked) .help { background: var(--surface); }
 }
 html:has(.pick-bar) { scroll-padding-bottom: 6rem; }  /* a field that takes focus is never behind the bar */
 
+/* Search and filters above the cards, from the seventh project on: the search is the suggestions' filter, and each link is a
+   pill with how many projects it leaves for the current search. The current one says so with a tick, not only a colour. */
+.find { display: grid; gap: var(--s2); margin: 0 0 var(--s4); }
+.find .filter, .find .filter-note { margin: 0; }
+.find .filter { max-width: 36rem; }
+.find-links ul { display: flex; flex-wrap: wrap; gap: var(--s2); margin: 0; padding: 0; list-style: none; }
+.find-links a {
+  display: inline-flex;
+  align-items: center;
+  gap: .5rem;
+  min-height: 44px;
+  padding: 0 var(--s3);
+  color: var(--text);
+  font-weight: 650;
+  text-decoration: none;
+  background: var(--surface);
+  border: 1.5px solid var(--line);
+  border-radius: var(--r-pill);
+}
+.find-links a:hover { border-color: var(--accent); background: var(--accent-soft); }
+.find-links a[aria-current] { background: var(--accent-soft); border-color: var(--accent); }
+.find-links a[aria-current]::before { content: "\2713"; color: var(--accent); }
+.find-links .count {
+  min-width: 1.5rem;
+  padding: 0 .4rem;
+  color: var(--muted);
+  font-size: .85rem;
+  font-variant-numeric: tabular-nums;
+  text-align: center;
+  background: var(--raised);
+  border-radius: var(--r-pill);
+}
+.find-links a[aria-current] .count { color: var(--on-accent); background: var(--accent); }
+
+/* With many projects, Run now is a fold, as Settings is: its form sits in it as the group's own panel. */
+.run-fold > .run-form { margin: 0 0 var(--s3); }
+
 /* ---------- Sign-in pages ---------- */
 .signed-out main { display: grid; align-content: start; }
 .sign-card {
diff --git a/src/lastcall/web/templates/_lists.html b/src/lastcall/web/templates/_lists.html
new file mode 100644
index 0000000..bb925dc
--- /dev/null
+++ b/src/lastcall/web/templates/_lists.html
@@ -0,0 +1,148 @@
+{#- A long list of containers (Settings › Container logs) or of sources in Loki (Settings › Logs in Loki), in three parts so
+    that it stays short: what lastcall reads now, what it suggests, and everything else in a fold with a filter by name.
+    Import with context, after _help.html's help macro: `lists` takes the page's help namespace `hb`.
+    `kind` is "logs" or "loki": it names the ids, the filter's address parameter (`logs_q`, `loki_q`) and the catalog
+    keys that differ. `v` is the view of the list (web.lists_view). `action` is where its forms post, `extra` the hidden
+    fields that each of them carries (the label that names the sources), `carry` the other list's filter, kept by this
+    list's own. `level` is the heading of the parts. -#}
+{% from "_help.html" import help with context %}
+
+{#- The name of a container or a source, with its state or the machines where it ran. -#}
+{% macro identity(item) -%}
+<p class="source-name"><strong class="mono">{{ item.name }}</strong>
+  {%- if item.state %} <span class="chip">{{ item.state }}</span>{% endif %}
+  {%- for host in item.hosts %} <span class="chip">{{ host }}</span>{% endfor %}</p>
+{%- endmacro %}
+
+{#- What helps to tell it from the others: a source's Compose project, a container's image. -#}
+{% macro clue(item, kind) -%}
+{%- if kind == "loki" and item.compose_project %}<p class="hint">{{ t("web.loki.compose", project=item.compose_project) }}</p>
+{%- elif kind == "logs" and item.image %}<p class="hint">{{ item.image }}</p>{% endif %}
+{%- endmacro %}
+
+{% macro hidden(extra) -%}
+<input type="hidden" name="csrf" value="{{ csrf }}">
+{%- for name, value in extra %}
+<input type="hidden" name="{{ name }}" value="{{ value }}">
+{%- endfor %}
+{%- endmacro %}
+
+{% macro lists(hb, kind, v, action, level="h4", extra=(), carry=()) %}
+{%- set post = action ~ "#" ~ kind %}
+<div class="parts">
+  <div class="part">
+    <{{ level }} class="part-title" id="{{ kind }}-read-title">{{ t("web.logs.read_title") }}</{{ level }}>
+    {%- if v.read %}
+    <ul class="rows reading" aria-labelledby="{{ kind }}-read-title">
+      {%- for r in v.read %}
+      <li>
+        <div class="read-main">
+          {{ identity(r) }}
+          <p class="small read-project"><span class="mono">{{ r.project }}</span> <span class="muted">· {{ t("web.logs.label_decides") if r.by == "label" else t("web.logs.chosen_here") }}</span></p>
+          {%- if r.unknown %}
+          <p class="hint">{{ t("web.logs.label_unknown", project=r.project) }}</p>
+          {%- endif %}
+          {%- if kind == "loki" %}{{ clue(r, kind) }}{% endif %}
+        </div>
+        {%- if r.by == "choice" %}
+        <form method="post" action="{{ post }}" class="row-actions">
+          {{ hidden(extra) }}
+          <input type="hidden" name="pick" value="stop">
+          <input type="hidden" name="name-1" value="{{ r.name }}">
+          <button class="secondary small-button" aria-label="{{ t('web.logs.stop_label', name=r.name) }}">{{ t("web.logs.stop") }}</button>
+        </form>
+        {%- endif %}
+      </li>
+      {%- endfor %}
+    </ul>
+    {%- else %}
+    <p class="muted small">{{ t("web.logs.read_none") }}</p>
+    {%- endif %}
+  </div>
+
+  {%- if v.suggested %}
+  <div class="part">
+    <div class="section-head"><{{ level }} class="part-title" id="{{ kind }}-suggested-title">{{ t("web.logs.suggested_title") }}</{{ level }}>{{ help(hb, "settings-logs_suggested", t("web.logs.suggested_title"), ["settings.logs_suggested"], true) }}</div>
+    <form method="post" action="{{ post }}" class="pick">
+      {{ hidden(extra) }}
+      <div class="pick-all">
+        <button class="secondary" name="pick" value="suggested">{{ tn("web.logs.read_suggested", v.suggested|length) }}</button>
+        <button class="secondary" name="pick" value="skip">{{ t("web.logs.skip_ticked") }}</button>
+      </div>
+      <fieldset class="picks" aria-labelledby="{{ kind }}-suggested-title">
+        <ul class="suggestions">
+          {%- for s in v.suggested %}
+          {%- set n = loop.index %}
+          <li class="suggestion">
+            <div class="pick-line">
+              <input id="{{ kind }}-pick-{{ n }}" type="checkbox" name="tick" value="{{ n }}" aria-describedby="{{ kind }}-for-{{ n }}">
+              <label for="{{ kind }}-pick-{{ n }}" class="suggestion-name">{{ s.name }}</label>
+            </div>
+            <p class="suggestion-meta" id="{{ kind }}-for-{{ n }}"><span>{{ t("web.logs.for_project", project=s.suggested) }}</span>
+              {%- if s.state %} <span class="chip">{{ s.state }}</span>{% endif %}
+              {%- for host in s.hosts %} <span class="chip">{{ host }}</span>{% endfor %}</p>
+            {%- if kind == "loki" %}{{ clue(s, kind) }}{% endif %}
+            <input type="hidden" name="name-{{ n }}" value="{{ s.name }}">
+            <input type="hidden" name="project-{{ n }}" value="{{ s.suggested }}">
+          </li>
+          {%- endfor %}
+        </ul>
+      </fieldset>
+      {#- Only the main action stays at the bottom of the screen, so that the bar is one button high on a phone. -#}
+      <div class="pick-bar">
+        <button name="pick" value="selected">{{ t("web.logs.read_ticked") }}</button>
+      </div>
+    </form>
+  </div>
+  {%- endif %}
+
+  {%- if v.total %}
+  <details class="fold others-fold"{% if v.query or v.typed %} open{% endif %}>
+    <summary>{{ tn("web." ~ kind ~ ".others", v.total) }}</summary>
+    <div class="fold-body">
+      {%- if v.filterable %}
+      <form method="get" action="{{ url_for('settings_page') }}#{{ kind }}" class="filter" role="search">
+        <label for="{{ kind }}-q">{{ t("web.suggest.filter") }}</label>
+        <div class="row">
+          <input id="{{ kind }}-q" name="{{ kind }}_q" type="search" value="{{ v.query }}" maxlength="100" autocomplete="off" spellcheck="false">
+          <button class="secondary">{{ t("web.suggest.filter_go") }}</button>
+        </div>
+        {%- for name, value in carry %}
+        <input type="hidden" name="{{ name }}" value="{{ value }}">
+        {%- endfor %}
+      </form>
+      {%- endif %}
+      {%- if v.query %}
+      <p class="filter-note">{{ tn("web.logs.matching", v.total, shown=v.others|length, query=v.query) }} <a href="{{ url_for('settings_page', **dict(carry)) }}#{{ kind }}">{{ t("web.suggest.show_all") }}</a></p>
+      {%- endif %}
+      {%- if v.others %}
+      <form method="post" action="{{ post }}" class="others-form">
+        {{ hidden(extra) }}
+        <div class="line"><p class="small muted">{{ t("web.logs.others_hint") }}</p>{{ help(hb, "settings-logs_project", t("web.logs.project"), ["settings.logs_project"], true) }}</div>
+        <ul class="rows others">
+          {%- for o in v.others %}
+          {%- set n = loop.index %}
+          <li>
+            <div class="other-main">
+              {{ identity(o) }}
+              {{ clue(o, kind) }}
+              {%- if o.gone %}
+              <p class="hint">{{ t("web.logs.gone", project=o.gone) }}</p>
+              {%- endif %}
+            </div>
+            <input type="hidden" name="name-{{ n }}" value="{{ o.name }}">
+            <input id="{{ kind }}-project-{{ n }}" name="project-{{ n }}" type="text" list="{{ kind }}-projects" value="{{ o.typed }}" placeholder="{{ t('web.logs.pick_placeholder') }}" aria-label="{{ t('web.logs.project_for', name=o.name) }}" maxlength="140" autocomplete="off" autocapitalize="none" spellcheck="false">
+          </li>
+          {%- endfor %}
+        </ul>
+        <datalist id="{{ kind }}-projects">
+          {%- for repo in v.repos %}<option value="{{ repo }}"></option>{% endfor %}
+        </datalist>
+        <button name="pick" value="others">{{ t("web.logs.save") }}</button>
+      </form>
+      {%- endif %}
+    </div>
+  </details>
+  {%- endif %}
+</div>
+{%- endmacro %}
diff --git a/src/lastcall/web/templates/accounts.html b/src/lastcall/web/templates/accounts.html
index 7a2cacc..5e1cf8b 100644
--- a/src/lastcall/web/templates/accounts.html
+++ b/src/lastcall/web/templates/accounts.html
@@ -125,7 +125,7 @@ <h1>{{ t("web.nav.accounts") }}</h1>
             <div class="fields">
               <div class="field">
                 <label for="model-{{ n }}-{{ tr.tier }}">{{ t("web.tiers.model") }}</label>
-                <input id="model-{{ n }}-{{ tr.tier }}" name="model-{{ tr.tier }}" type="text" value="{{ tr.model }}" placeholder="{{ tr.default_model }}" maxlength="100" autocomplete="off" spellcheck="false"{% if not tr.default_model %} required{% endif %}>
+                <input id="model-{{ n }}-{{ tr.tier }}" name="model-{{ tr.tier }}" type="text" value="{{ tr.model }}" placeholder="{{ tr.default_model }}" maxlength="100" autocomplete="off" spellcheck="false"{% if c.suggest %} list="{{ c.suggest.list }}"{% endif %}{% if not tr.default_model %} required{% endif %}>
               </div>
               <div class="field">
                 <div class="label-row"><label for="effort-{{ n }}-{{ tr.tier }}">{{ t("web.tiers.effort") }}</label>{% if loop.first %}{{ help(hb, "accounts-effort", t("web.tiers.effort"), ["accounts.effort"], true) }}{% endif %}</div>
@@ -138,6 +138,9 @@ <h1>{{ t("web.nav.accounts") }}</h1>
           </fieldset>
           {%- endfor %}
           <p class="hint">{{ t("web.tiers.keyed_hint") if row.keyed else t("web.tiers.default_hint") }}</p>
+          {%- if c.suggest %}
+          <p class="hint">{{ c.suggest.note }}</p>
+          {%- endif %}
           <button class="secondary">{{ t("web.tiers.save") }}</button>
         </form>
       </div>
@@ -228,12 +231,12 @@ <h3>{{ t("web.accounts.kind.key") }}</h3>
         </div>
         <div class="field">
           <label for="key-model">{{ t("web.accounts.model_label") }}</label>
-          <input id="key-model" name="model" type="text" value="{{ f.model or '' }}" autocomplete="off" spellcheck="false" required aria-describedby="key-model-hint">
-          <p id="key-model-hint" class="hint">{{ t("web.accounts.model_hint") }}</p>
+          <input id="key-model" name="model" type="text" value="{{ f.model or '' }}" autocomplete="off" spellcheck="false"{% if key_list %} list="{{ key_list }}"{% endif %} required aria-describedby="key-model-hint">
+          <p id="key-model-hint" class="hint">{{ t("web.accounts.model_hint") }}{% if key_list %} {{ t("web.accounts.model_suggest") }}{% endif %}</p>
         </div>
         <div class="field">
           <div class="label-row"><label for="key-review">{{ t("web.accounts.review_label") }}</label>{{ help(hb, "accounts-review", t("web.accounts.review_label"), ["accounts.review_model"], true) }}</div>
-          <input id="key-review" name="review_model" type="text" value="{{ f.review_model or '' }}" autocomplete="off" spellcheck="false" aria-describedby="key-review-hint">
+          <input id="key-review" name="review_model" type="text" value="{{ f.review_model or '' }}" autocomplete="off" spellcheck="false"{% if key_list %} list="{{ key_list }}"{% endif %} aria-describedby="key-review-hint">
           <p id="key-review-hint" class="hint">{{ t("web.accounts.review_hint") }}</p>
         </div>
         <div class="field">
@@ -311,5 +314,10 @@ <h3>{{ t("web.accounts.kind.local") }}</h3>
     {%- endif %}
   </div>
 </section>
+{#- The datalists that the model fields point to (`list`): one for each kind of account on the page, whatever the number of
+    its cards. A browser shows them as suggestions and lets the owner type any other name. -#}
+{%- for list_id, names in datalists.items() %}
+<datalist id="{{ list_id }}">{% for name in names %}<option value="{{ name }}"></option>{% endfor %}</datalist>
+{%- endfor %}
 {{ bubbles(hb) }}
 {% endblock %}
diff --git a/src/lastcall/web/templates/projects.html b/src/lastcall/web/templates/projects.html
index b63480f..6be188b 100644
--- a/src/lastcall/web/templates/projects.html
+++ b/src/lastcall/web/templates/projects.html
@@ -11,7 +11,7 @@
 <header class="page-head">
   <h1>{{ t("web.projects.title") }}</h1>
   <p class="lede">{{ t("web.projects.intro") }}</p>
-  {%- if v.projects %}<p class="jump"><a href="#add-title">{{ t("web.add.title") }}</a></p>{% endif %}
+  {%- if v.known %}<p class="jump"><a href="#add-title">{{ t("web.add.title") }}</a></p>{% endif %}
 </header>
 
 {% if done %}<p class="notice done" role="status">{{ done }}</p>{% endif %}
@@ -73,10 +73,13 @@ <h3>{{ t("web.suggest.title") }}</h3>
       <input id="q" name="q" type="search" value="{{ v.query }}" maxlength="100" autocomplete="off" spellcheck="false">
       <button class="secondary">{{ t("web.suggest.filter_go") }}</button>
     </div>
+    {#- the search and the filter of the cards stay as they are -#}
+    {%- if v.search %}<input type="hidden" name="search" value="{{ v.search }}">{% endif %}
+    {%- if v.show != "all" %}<input type="hidden" name="show" value="{{ v.show }}">{% endif %}
   </form>
   {%- endif %}
   {%- if v.query %}
-  <p class="filter-note">{{ tn("web.suggest.matching", v.total, shown=v.shown, query=v.query) }} <a href="{{ url_for('projects_page') }}#suggestions">{{ t("web.suggest.show_all") }}</a></p>
+  <p class="filter-note">{{ tn("web.suggest.matching", v.total, shown=v.shown, query=v.query) }} <a href="{{ url_for('projects_page', search=v.search or None, show=v.show if v.show != 'all' else None) }}#suggestions">{{ t("web.suggest.show_all") }}</a></p>
   {%- endif %}
   {%- if v.shown %}
   <form method="post" action="{{ url_for('add_projects') }}" class="pick">
@@ -119,11 +122,39 @@ <h3>{{ t("web.suggest.title") }}</h3>
 </section>
 {%- endmacro %}
 
-{% if not v.projects %}
+{% if not v.known %}
 <p class="empty">{{ t("web.projects.empty") if v.github_ready else t("web.projects.none") }}</p>
 {{ add_section() }}
 {% else %}
 <section aria-label="{{ t('web.projects.title') }}">
+  {#- With many projects: a search by name and the filters, above the cards. Each link keeps the search and the filter of the
+      suggestions below, and all of them bring the page back here (#find). Their counts are those of the current search. -#}
+  {%- if v.can_search %}
+  <div class="find" id="find">
+    <form method="get" action="{{ url_for('projects_page') }}#find" class="filter" role="search">
+      <label for="search">{{ t("web.projects.search") }}</label>
+      <div class="row">
+        <input id="search" name="search" type="search" value="{{ v.search }}" maxlength="100" autocomplete="off" spellcheck="false">
+        <button class="secondary">{{ t("web.projects.search_go") }}</button>
+      </div>
+      {%- if v.show != "all" %}<input type="hidden" name="show" value="{{ v.show }}">{% endif %}
+      {%- if v.query %}<input type="hidden" name="q" value="{{ v.query }}">{% endif %}
+    </form>
+    <nav class="find-links" aria-label="{{ t('web.projects.show') }}">
+      <ul>
+        {%- for f in v.filters %}
+        <li><a href="{{ url_for('projects_page', show=f.key if f.key != 'all' else None, search=v.search or None, q=v.query or None) }}#find"{% if f.current %} aria-current="true"{% endif %}>{{ f.label }} <span class="count">{{ f.count }}</span></a></li>
+        {%- endfor %}
+      </ul>
+    </nav>
+    {%- if v.search or v.show != "all" %}
+    <p class="filter-note">{{ tn("web.projects.showing", v.known, shown=v.projects|length) }}</p>
+    {%- endif %}
+  </div>
+  {%- endif %}
+  {%- if not v.projects %}
+  <p class="empty">{{ t("web.projects.no_match") }} <a href="{{ url_for('projects_page', q=v.query or None) }}#find">{{ t("web.projects.show_all") }}</a></p>
+  {%- else %}
   <div class="grid projects">
     {%- for p in v.projects %}
     {%- set n = loop.index %}
@@ -183,12 +214,22 @@ <h3 id="remove-title-{{ n }}">{{ t("web.project.remove_title", repo=p.repo) }}</
       {%- if p.busy %}
       <p class="working busy">{{ p.busy }}</p>
       {%- elif v.accounts|length > 1 %}
+      {#- With many projects the group starts folded, like the settings below it, so that the cards are short: its title is
+          the summary that opens it, and its "?" moves inside, after a line that says what the group does. -#}
+      {%- if v.many %}
+      <details class="fold run-fold">
+        <summary>{{ t("web.project.run_now") }}</summary>
+      {%- endif %}
       <form method="post" action="{{ url_for('audit_now', owner=p.owner, name=p.name) }}" class="run-form">
         <input type="hidden" name="csrf" value="{{ csrf }}">
-        <fieldset class="run-now has-help">
+        <fieldset class="run-now{% if not v.many %} has-help{% endif %}"{% if v.many %} aria-label="{{ t('web.project.run_now') }}"{% endif %}>
+          {%- if v.many %}
+          <div class="line"><p class="small muted">{{ t("web.project.run_summary") }}</p>{{ help(hb, "projects-run_now", t("web.project.run_now"), ["projects.run_now"], true) }}</div>
+          {%- else %}
           <legend>{{ t("web.project.run_now") }}</legend>{{ help(hb, "projects-run_now", t("web.project.run_now"), ["projects.run_now"]) }}
+          {%- endif %}
           <div class="field">
-            <div class="label-row"><label for="account-{{ n }}">{{ t("web.project.account") }}</label>{{ help(hb, "projects-account", t("web.project.account"), account_keys) }}</div>
+            <div class="label-row"><label for="account-{{ n }}">{{ t("web.project.account") }}</label>{{ help(hb, "projects-account", t("web.project.account"), account_keys, v.many) }}</div>
             <select id="account-{{ n }}" name="account">
               {%- for o in v.accounts %}<option value="{{ o.value }}"{% if o.selected %} selected{% endif %}>{{ o.label }}</option>{% endfor %}
             </select>
@@ -200,12 +241,15 @@ <h3 id="remove-title-{{ n }}">{{ t("web.project.remove_title", repo=p.repo) }}</
             <button class="secondary" formaction="{{ url_for('deps_now', owner=p.owner, name=p.name) }}">{{ t("web.project.deps_now") }}</button>
           </div>
           <ul class="run-hints" aria-label="{{ t('web.project.run_hints') }}">
-            <li><p>{{ t("web.project.improve_hint") }}</p>{{ help(hb, "projects-improve", t("web.project.improve"), ["projects.improve"]) }}</li>
+            <li><p>{{ t("web.project.improve_hint") }}</p>{{ help(hb, "projects-improve", t("web.project.improve"), ["projects.improve"], v.many) }}</li>
             <li><p>{{ t("web.project.tests_hint") }}</p></li>
             <li><p>{{ t("web.project.deps_hint") }}</p></li>
           </ul>
         </fieldset>
       </form>
+      {%- if v.many %}
+      </details>
+      {%- endif %}
       {%- else %}
       <p class="muted">{{ t("web.project.no_accounts") }}</p>
       {%- endif %}
@@ -233,9 +277,10 @@ <h3 id="remove-title-{{ n }}">{{ t("web.project.remove_title", repo=p.repo) }}</
             <div class="fields">
               <div class="field">
                 <div class="label-row"><label for="language-{{ n }}">{{ t("web.project.language") }}</label>{{ help(hb, "projects-language", t("web.project.language"), ["projects.language"], true) }}</div>
-                <select id="language-{{ n }}" name="language">
+                <select id="language-{{ n }}" name="language" aria-describedby="language-hint-{{ n }}">
                   {%- for o in p.languages %}<option value="{{ o.value }}"{% if o.selected %} selected{% endif %}>{{ o.label }}</option>{% endfor %}
                 </select>
+                <p class="hint" id="language-hint-{{ n }}">{{ t("web.project.language_hint") }}</p>
               </div>
               <div class="field">
                 <div class="label-row"><label for="max-prs-{{ n }}">{{ t("web.project.max_prs") }}</label>{{ help(hb, "projects-max_prs", t("web.project.max_prs"), ["projects.max_prs"], true) }}</div>
@@ -270,6 +315,7 @@ <h3 id="remove-title-{{ n }}">{{ t("web.project.remove_title", repo=p.repo) }}</
     </article>
     {%- endfor %}
   </div>
+  {%- endif %}
 </section>
 {{ add_section() }}
 {% endif %}
diff --git a/src/lastcall/web/templates/settings.html b/src/lastcall/web/templates/settings.html
index 4243fef..4feb0de 100644
--- a/src/lastcall/web/templates/settings.html
+++ b/src/lastcall/web/templates/settings.html
@@ -2,6 +2,7 @@
 {% block title %}{{ t("web.settings.title") }}{% endblock %}
 {% block main %}
 {%- from "_help.html" import help, bubbles with context %}
+{%- from "_lists.html" import lists with context %}
 {%- set hb = namespace(items=[], seen=[]) %}
 {%- set event_help = ("decisions", "merged", "reverted", "paid", "quota", "burst") %}
 <header class="page-head">
@@ -317,36 +318,15 @@ <h3 id="logs-title">{{ t("web.logs.title") }}</h3>
       <li>{{ t("web.logs.step1") }}</li>
       <li>{{ t("web.logs.step2") }}</li>
     </ol>
+    {%- if logs_error %}
+    <p class="notice error" role="alert">{{ logs_error }}</p>
+    {%- endif %}
     {%- if v.logs.error %}
     <p class="notice error" role="alert">{{ v.logs.error }}</p>
-    {%- elif not v.logs.rows %}
+    {%- elif not v.logs.count %}
     <p class="empty">{{ t("web.logs.none") }}</p>
     {%- else %}
-    <form method="post" action="{{ url_for('logs_settings') }}#logs" class="stack">
-      <input type="hidden" name="csrf" value="{{ csrf }}">
-      <ul class="rows sources">
-        {%- for c in v.logs.rows %}
-        <li>
-          <p class="source-name"><strong id="logs-name-{{ loop.index }}">{{ c.name }}</strong> <span class="chip">{{ c.state }}</span></p>
-          <p class="hint">{{ c.image }}</p>
-          {%- if c.label %}
-          <p class="small">{{ t("web.logs.from_label", project=c.label) }}</p>
-          {%- else %}
-          <input type="hidden" name="name-{{ loop.index }}" value="{{ c.name }}">
-          <input type="hidden" name="shown-{{ loop.index }}" value="{{ c.selected }}">
-          <div class="label-row"><label for="logs-{{ loop.index }}" class="small">{{ t("web.logs.project") }}</label>{{ help(hb, "settings-logs_project", t("web.logs.project"), ["settings.logs_project"]) }}</div>
-          <select id="logs-{{ loop.index }}" aria-describedby="logs-name-{{ loop.index }}" name="project-{{ loop.index }}">
-            <option value="">{{ t("web.logs.not_read") }}</option>
-            {%- for repo in v.logs.repos %}<option value="{{ repo }}"{% if repo == c.selected %} selected{% endif %}>{{ repo }}</option>{% endfor %}
-          </select>
-          {%- if c.suggested %}<p class="hint">{{ t("web.logs.suggested", project=c.suggested) }}</p>{% endif %}
-          {%- if c.gone %}<p class="hint">{{ t("web.logs.gone", project=c.gone) }}</p>{% endif %}
-          {%- endif %}
-        </li>
-        {%- endfor %}
-      </ul>
-      <button>{{ t("web.logs.save") }}</button>
-    </form>
+    {{ lists(hb, "logs", v.logs, url_for('logs_settings'), "h4", (), [("loki_q", v.loki.query)] if v.loki.query else []) }}
     {%- endif %}
     <details class="fold">
       <summary>{{ t("web.logs.label_title") }}</summary>
@@ -416,32 +396,11 @@ <h3 id="logs-title">{{ t("web.logs.title") }}</h3>
       </div>
       <button class="secondary">{{ t("web.loki.use_label") }}</button>
     </form>
-    {%- if v.loki.label and not v.loki.rows %}
+    {%- if v.loki.label and not v.loki.count %}
     <p class="empty">{{ t("web.loki.none") }}</p>
-    {%- elif v.loki.rows %}
-    <form method="post" action="{{ url_for('loki_sources') }}#loki" class="stack">
-      <input type="hidden" name="csrf" value="{{ csrf }}">
-      <input type="hidden" name="label" value="{{ v.loki.label }}">
-      <div class="section-head"><h4>{{ t("web.help.settings.loki_sources.title") }}</h4>{{ help(hb, "settings-loki_sources", t("web.help.settings.loki_sources.title"), ["settings.loki_sources"]) }}</div>
-      <ul class="rows sources">
-        {%- for s in v.loki.rows %}
-        <li>
-          <p class="source-name"><strong id="loki-name-{{ loop.index }}">{{ s.name }}</strong>{% for host in s.hosts %} <span class="chip">{{ host }}</span>{% endfor %}</p>
-          {%- if s.compose_project %}<p class="hint">{{ t("web.loki.compose", project=s.compose_project) }}</p>{% endif %}
-          <input type="hidden" name="name-{{ loop.index }}" value="{{ s.name }}">
-          <input type="hidden" name="shown-{{ loop.index }}" value="{{ s.selected }}">
-          <label for="loki-{{ loop.index }}" class="small">{{ t("web.logs.project") }}</label>
-          <select id="loki-{{ loop.index }}" aria-describedby="loki-name-{{ loop.index }}" name="project-{{ loop.index }}">
-            <option value="">{{ t("web.logs.not_read") }}</option>
-            {%- for repo in v.loki.repos %}<option value="{{ repo }}"{% if repo == s.selected %} selected{% endif %}>{{ repo }}</option>{% endfor %}
-          </select>
-          {%- if s.suggested %}<p class="hint">{{ t("web.logs.suggested", project=s.suggested) }}</p>{% endif %}
-          {%- if s.gone %}<p class="hint">{{ t("web.logs.gone", project=s.gone) }}</p>{% endif %}
-        </li>
-        {%- endfor %}
-      </ul>
-      <button>{{ t("web.logs.save") }}</button>
-    </form>
+    {%- elif v.loki.count %}
+    <div class="section-head"><h4>{{ t("web.help.settings.loki_sources.title") }}</h4>{{ help(hb, "settings-loki_sources", t("web.help.settings.loki_sources.title"), ["settings.loki_sources"]) }}</div>
+    {{ lists(hb, "loki", v.loki, url_for('loki_sources'), "h5", [("label", v.loki.label)], [("logs_q", v.logs.query)] if v.logs.query else []) }}
     {%- endif %}
     {%- endif %}
     <form method="post" action="{{ url_for('disconnect_loki') }}#loki">
diff --git a/tests/test_catalog.py b/tests/test_catalog.py
new file mode 100644
index 0000000..78fac72
--- /dev/null
+++ b/tests/test_catalog.py
@@ -0,0 +1,206 @@
+"""models.dev's catalog, as the web UI reads it: which models a provider offers that a step can run on. The tests
+never ask models.dev: `ModelsDev` is a `fetch` that answers from a small catalog of the shape that it has."""
+
+import gzip
+import json
+import urllib.request
+import zlib
+from collections.abc import Mapping
+from typing import Any
+
+import pytest
+
+from lastcall import __version__, catalog, engines
+from lastcall.accounts import MODEL
+from lastcall.engines.base import Keyed
+from lastcall.github import Fetch, Response
+
+
+def model(**fields: Any) -> dict[str, Any]:
+    """One model of a provider: it calls tools and has a price, until a field says otherwise."""
+    return {"name": "A model", "tool_call": True, "cost": {"input": 1.5, "output": 7.5}, **fields}
+
+
+CATALOG: dict[str, Any] = {
+    "openrouter": {
+        "id": "openrouter",
+        "name": "OpenRouter",
+        "models": {
+            "qwen/qwen3-coder": model(),
+            "Qwen/Qwen3-coder-flash": model(),  # the order is alphabetical whatever the case
+            "qwen/qwen3-coder:free": model(cost={"input": 0, "output": 0}),  # free is a price
+            "anthropic/claude-sonnet-5.5": model(),
+            "~anthropic/claude-sonnet-latest": model(),  # an alias that an account cannot name: it starts with ~
+            "legacy/old-model": model(status="deprecated"),
+            "beta/new-model": model(status="beta"),  # not deprecated: it stays
+            "writer/no-tools": model(tool_call=False),
+            "writer/tools-unknown": {"cost": {"input": 1, "output": 2}},
+            "writer/no-price": {"tool_call": True},
+            "writer/half-price": model(cost={"input": 1}),
+            "writer/odd-price": model(cost={"input": "1", "output": True}),
+        },
+    },
+    "anthropic": {"id": "anthropic", "models": {"claude-sonnet-5-5": model(), "claude-opus-5-5": model()}},
+    "openai": {"id": "openai", "models": {"gpt-6.1-sol": model(), "gpt-image-2": model(tool_call=False)}},
+    "ollama-cloud": {"id": "ollama-cloud", "models": {"kimi-k3": model()}},  # not a provider that lastcall asks about
+}
+URL = "https://models.dev/api.json"
+Answer = Mapping[str, Any] | Exception | tuple[int, bytes]
+
+
+class ModelsDev:
+    """A `fetch` that answers what models.dev would: the catalog (gzipped, as it is when it is asked for gzip), or the
+    exception that a network that fails raises, or a status and a body. It records every request it gets."""
+
+    def __init__(self, answer: Answer = CATALOG, packed: bool = True) -> None:
+        self.answer, self.packed = answer, packed
+        self.asked: list[urllib.request.Request] = []
+
+    def __call__(self, req: urllib.request.Request) -> Response:
+        self.asked.append(req)
+        assert req.full_url == URL, req.full_url
+        if isinstance(self.answer, Exception):
+            raise self.answer
+        if isinstance(self.answer, tuple):
+            status, body = self.answer
+            return status, {}, body
+        body = json.dumps(self.answer).encode()
+        if self.packed:
+            return 200, {"Content-Type": "application/json", "Content-Encoding": "gzip"}, gzip.compress(body)
+        return 200, {"Content-Type": "application/json"}, body
+
+
+def says(body: bytes, headers: Mapping[str, str] | None = None) -> Fetch:
+    """A `fetch` that answers 200 with this body and these headers, whatever it is asked."""
+
+    def fetch(req: urllib.request.Request) -> Response:
+        return 200, dict(headers or {}), body
+
+    return fetch
+
+
+def listed(provider: str) -> tuple[str, ...]:
+    return catalog.models(ModelsDev(), [provider], 5)[provider]
+
+
+def test_it_keeps_the_models_that_a_step_can_run_on() -> None:
+    assert listed("openrouter") == (
+        "anthropic/claude-sonnet-5.5",
+        "beta/new-model",
+        "qwen/qwen3-coder",
+        "Qwen/Qwen3-coder-flash",
+        "qwen/qwen3-coder:free",
+    )
+    assert listed("anthropic") == ("claude-opus-5-5", "claude-sonnet-5-5")
+    assert listed("openai") == ("gpt-6.1-sol",)
+
+
+def test_every_name_that_it_keeps_is_one_that_an_account_takes() -> None:
+    assert all(MODEL.fullmatch(name) for name in listed("openrouter"))
+    assert "~anthropic/claude-sonnet-latest" not in listed("openrouter")
+
+
+def test_one_request_answers_for_every_provider_and_a_missing_provider_has_none() -> None:
+    fetch = ModelsDev()
+    found = catalog.models(fetch, ["openrouter", "anthropic", "openai", "nobody"], 5)
+    assert len(fetch.asked) == 1
+    assert found["nobody"] == () and found["anthropic"] == ("claude-opus-5-5", "claude-sonnet-5-5")
+    assert "ollama-cloud" not in found  # it keeps only the providers that it is asked about
+
+
+def test_the_request_says_who_asks_wants_gzip_and_waits_5_seconds_and_carries_nothing_of_the_owner() -> None:
+    fetch = ModelsDev()
+    catalog.models(fetch, ["openai"], 5)
+    (req,) = fetch.asked
+    assert req.full_url == "https://models.dev/api.json" and req.get_method() == "GET" and req.data is None
+    assert req.get_header("User-agent") == f"lastcall/{__version__} (+https://github.com/ne0x86/lastcall)"
+    assert req.get_header("Accept-encoding") == "gzip" and getattr(req, "timeout", None) == 5
+    assert not req.has_header("Authorization") and not req.has_header("Cookie")
+
+
+@pytest.mark.parametrize("packed", [True, False])
+def test_a_gzipped_answer_and_a_plain_one_read_the_same(packed: bool) -> None:
+    found = catalog.models(ModelsDev(packed=packed), ["anthropic"], 5)
+    assert found == {"anthropic": ("claude-opus-5-5", "claude-sonnet-5-5")}
+
+
+def test_the_header_that_says_gzip_is_read_whatever_its_case() -> None:
+    fetch = says(gzip.compress(json.dumps(CATALOG).encode()), {"content-encoding": " GZip "})
+    assert catalog.models(fetch, ["openai"], 5) == {"openai": ("gpt-6.1-sol",)}
+
+
+@pytest.mark.parametrize(
+    "answer",
+    [
+        (404, b"{}"),
+        (403, gzip.compress(b"<html>Forbidden</html>")),  # what models.dev says to a request with no User-Agent
+        (500, b""),
+        (200, b""),
+        (200, b"<html>a captive portal</html>"),
+        (200, b'["not", "the", "catalog"]'),
+        (200, b"null"),
+        OSError("no route to host"),
+        TimeoutError("timed out"),
+    ],
+)
+def test_an_answer_that_is_not_the_catalog_is_an_error(answer: Answer) -> None:
+    with pytest.raises((OSError, ValueError)):
+        catalog.models(ModelsDev(answer), ["openrouter"], 5)
+
+
+def test_a_gzip_that_is_broken_is_an_error() -> None:
+    with pytest.raises(zlib.error):
+        catalog.models(says(b"this is not gzip", {"Content-Encoding": "gzip"}), ["openrouter"], 5)
+
+
+@pytest.mark.parametrize(
+    "entry",
+    [None, [], "openrouter", 3, {}, {"models": None}, {"models": []}, {"models": "x"}, {"models": {"a/b": "text"}}],
+)
+def test_a_provider_that_does_not_look_like_one_has_no_models(entry: object) -> None:
+    assert catalog.models(ModelsDev({"p": entry}), ["p"], 5) == {"p": ()}
+
+
+def test_what_else_the_catalog_says_about_a_model_does_not_matter() -> None:
+    odd = {"p": {"models": {"a/b": model(cost={"input": 1, "output": 2, "cache_read": None, "tiers": [{"x": 1}]})}}}
+    assert catalog.models(ModelsDev(odd), ["p"], 5) == {"p": ("a/b",)}
+
+
+def test_a_provider_keeps_at_most_max_models_the_first_in_alphabetical_order(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(catalog, "MAX_MODELS", 3)
+    many = {"p": {"models": {f"vendor/m{n:02}": model() for n in range(20, 0, -1)}}}
+    assert catalog.models(ModelsDev(many), ["p"], 5) == {"p": ("vendor/m01", "vendor/m02", "vendor/m03")}
+
+
+def test_an_answer_over_the_limit_is_refused_packed_or_not(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(catalog, "MAX_BYTES", 1000)
+    big = {"p": {"models": {f"vendor/model-{n}": model() for n in range(100)}}}
+    for packed in (True, False):
+        with pytest.raises(ValueError, match="too big"):
+            catalog.models(ModelsDev(big, packed=packed), ["p"], 5)
+
+
+def test_a_few_kilobytes_that_unpack_to_megabytes_are_refused_while_they_unpack(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
+    monkeypatch.setattr(catalog, "MAX_BYTES", 1024 * 1024)
+    bomb = gzip.compress(b" " * (20 * 1024 * 1024))  # 20 MB of spaces, 20 KB packed: under the limit as it comes
+    assert len(bomb) < 100 * 1024
+    with pytest.raises(ValueError, match="too big"):
+        catalog.models(says(bomb, {"Content-Encoding": "gzip"}), ["openrouter"], 5)
+
+
+def test_an_answer_of_exactly_the_limit_is_read(monkeypatch: pytest.MonkeyPatch) -> None:
+    body = json.dumps(CATALOG).encode()
+    monkeypatch.setattr(catalog, "MAX_BYTES", len(body))  # its size, plain or unpacked
+    assert catalog.models(says(body), ["openai"], 5) == {"openai": ("gpt-6.1-sol",)}
+    packed = says(gzip.compress(body), {"Content-Encoding": "gzip"})
+    assert catalog.models(packed, ["openai"], 5) == {"openai": ("gpt-6.1-sol",)}
+
+
+def test_each_api_provider_of_opencode_says_its_id_in_models_dev_and_a_local_server_has_none() -> None:
+    engine = engines.get("opencode")
+    assert isinstance(engine, Keyed)
+    found = {p.name: p.catalog for p in engine.providers}
+    assert found == {"openrouter": "openrouter", "anthropic": "anthropic", "openai": "openai", "ollama": ""}
+    assert all(p.keys for p in engine.providers if p.catalog)  # an API takes a key; a local server has none
diff --git a/tests/test_docs.py b/tests/test_docs.py
index 4a59adf..e550d04 100644
--- a/tests/test_docs.py
+++ b/tests/test_docs.py
@@ -3,6 +3,7 @@
 import json
 import re
 from pathlib import Path
+from typing import Any
 
 ROOT = Path(__file__).resolve().parents[1]
 README = (ROOT / "README.md").read_text(encoding="utf-8")
@@ -103,3 +104,66 @@ def test_the_documents_describe_the_state_chip_and_the_trash_button() -> None:
     assert '"/projects/<owner>/<name>/active"' in source and '"/projects/<owner>/<name>/remove"' in source
     cli = (ROOT / "src/lastcall/cli.py").read_text(encoding="utf-8")
     assert "lastcall project remove <owner/name>" in cli and "cli project remove <owner/name>" in README
+
+
+def tiers_json() -> dict[str, Any]:
+    found: dict[str, Any] = json.loads((ROOT / "src/lastcall/data/tiers.json").read_text(encoding="utf-8"))
+    return found
+
+
+def test_the_readme_example_of_a_default_is_the_one_in_data_tiers_json() -> None:
+    model, effort = tiers_json()["claude-code"]["deep"]
+    assert f"such as {model} at `{effort}` effort for Claude Code's *deep*" in " ".join(README.split())
+
+
+def test_the_documents_say_why_the_efforts_differ_and_name_the_ones_of_data_tiers_json() -> None:
+    data = tiers_json()
+    efforts = {tier: data["claude-code"][tier][1] for tier in ("fast", "balanced", "deep")}
+    assert efforts == {tier: data["codex"][tier][1] for tier in efforts}  # one reason for both engines
+    assert len(set(efforts.values())) == 3  # they differ
+    readme = " ".join(README.split())
+    assert "The efforts differ because the work does" in readme
+    assert f"*deep* runs at `{efforts['deep']}`" in readme and f"*balanced* at `{efforts['balanced']}`" in readme
+    assert f"at `{efforts['fast']}`." in readme
+    section = " ".join(DESIGN.split("### Tiers and models")[1].split("### Engines")[0].split())
+    assert "The default efforts differ by tier because the work does" in section
+    assert f"so it takes `{efforts['fast']}`" in section and f"at `{efforts['balanced']}`" in section
+    assert f"at `{efforts['deep']}`" in section and "where quality matters most" in section
+
+
+def test_the_documents_say_where_the_suggested_models_come_from() -> None:
+    import lastcall.web as site
+    from lastcall import catalog
+
+    section = " ".join(DESIGN.split("### Tiers and models")[1].split("### Engines")[0].split())
+    for words in (
+        "**Suggested models.**",
+        "`<datalist>`",
+        "the `models` of its engine in the data file",
+        "https://models.dev/api.json",
+        "`Provider.catalog`",
+        "A local model server (Ollama) gets no suggestions",
+        "`fable` is left out on purpose",
+    ):
+        assert words in section, words
+    for name in tiers_json()["models"]["claude-code"]:
+        assert f"`{name}`" in section, name  # the aliases that the data file lists
+    # the numbers that it gives are the code's
+    assert (site.CATALOG_TIMEOUT, site.CATALOG_SECONDS, site.CATALOG_RETRY_SECONDS) == (5, 86_400, 600)
+    assert "waits 5 seconds at most" in section and "stays in memory for a day" in section
+    assert "A failure is kept for 10 minutes" in section
+    assert catalog.MAX_MODELS == 1000 and "at most 1000 models" in section
+    assert "ask [models.dev](https://models.dev), about once a day, for the names of the models" in " ".join(
+        README.split()
+    )
+
+
+def test_the_documents_say_that_only_the_checks_and_the_health_address_take_part_in_the_watch() -> None:
+    after = " ".join(README.split("**After the merge.**")[1].split("\n## ")[0].split())
+    assert (
+        "Nothing else takes part in the watch: container logs, Loki and your error tracker feed the audits" in after
+    )
+    deployment = " ".join(DESIGN.split("## 11. Delivery, approval and after the merge")[1].split("## 12.")[0].split())
+    assert (
+        "Errors in production feed the audits since v0.5, and container logs and their state since v0.6" in deployment
+    )
diff --git a/tests/test_i18n.py b/tests/test_i18n.py
index 1064ea7..2f18c6f 100644
--- a/tests/test_i18n.py
+++ b/tests/test_i18n.py
@@ -95,3 +95,51 @@ def test_the_texts_about_the_checks_call_the_two_settings_as_the_projects_page_d
         permissions = text(lang, "web.help.github.permissions")  # what the manifest asks for, and why
         for label in (merge, watch):
             assert label in lead and label in permissions, (lang, label)
+
+
+def test_the_help_of_a_projects_language_quotes_the_option_where_it_really_is() -> None:
+    for lang in ("en", "es"):
+        assert text(lang, "web.project.language.account") in text(lang, "web.help.projects.language"), lang
+
+
+def test_the_help_of_the_turns_calls_the_two_boxes_and_the_two_buttons_as_the_page_does() -> None:
+    for lang in ("en", "es"):
+        turns = text(lang, "web.help.projects.turns")
+        for key in ("web.project.tests", "web.project.deps", "web.project.tests_now", "web.project.deps_now"):
+            assert text(lang, key) in turns, (lang, key)
+
+
+def test_the_help_of_the_watch_calls_the_active_box_as_the_page_does() -> None:
+    for lang in ("en", "es"):
+        assert text(lang, "web.project.active") in text(lang, "web.help.projects.watch"), lang
+
+
+def test_the_hint_and_the_help_of_the_watch_both_say_that_logs_do_not_take_part() -> None:
+    said = {
+        "en": ("not your logs or error tracker", "take no part in the watch"),
+        "es": ("no tus logs ni tu tracker de errores", "no intervienen en la vigilancia"),
+    }
+    for lang, (hint, bubble) in said.items():
+        assert hint in text(lang, "web.project.watch_hint"), lang
+        assert bubble in text(lang, "web.help.projects.watch"), lang
+
+
+def test_the_help_about_effort_names_no_default_so_that_the_data_file_alone_decides_them() -> None:
+    for lang, catalog in MESSAGES.items():
+        for key, template in catalog.items():
+            if key.startswith(("web.tiers.", "web.help.accounts.")):
+                assert "xhigh" not in template, (lang, key)
+
+
+def test_the_suggestions_say_where_they_come_from_in_both_languages() -> None:
+    for lang in ("en", "es"):
+        assert "models.dev" in text(lang, "web.tiers.suggest.catalog", provider="OpenRouter"), lang
+        assert "Codex" in text(lang, "web.tiers.suggest.cli", tool="Codex"), lang
+        assert "qwen/qwen3-coder" in text(lang, "web.accounts.model_suggest"), lang
+
+
+def test_the_default_language_of_a_project_fits_a_closed_select_on_a_phone() -> None:
+    """A closed select cuts its text short: about 30 characters fit in a phone's, and the field is cut at 24 to leave
+    room for the narrower ones."""
+    for lang in ("en", "es"):
+        assert len(text(lang, "web.project.language.account")) <= 24, lang
diff --git a/tests/test_keyed.py b/tests/test_keyed.py
index 783b661..2472381 100644
--- a/tests/test_keyed.py
+++ b/tests/test_keyed.py
@@ -65,7 +65,7 @@ def test_models_come_per_tier_and_keep_the_default_effort() -> None:
     assert tier_models("") == {}
     assert openrouter().tiers()["deep"] == ("qwen/qwen3-coder", None)
     claude = Account("claude", "claude-code", models={"deep": "sonnet"})
-    assert claude.tiers()["deep"] == ("sonnet", "high")  # the account's own model, the default effort
+    assert claude.tiers()["deep"] == ("sonnet", "xhigh")  # the account's own model, the default effort
     assert claude.tiers()["fast"] == ("haiku", "medium")
 
 
@@ -93,7 +93,7 @@ def test_an_account_chooses_the_model_and_effort_of_each_tier(
     row = store.account("max")
     assert row is not None and row.account().tiers() == claude.tiers()
     assert cli.main(["account", "tier", "max", "deep", "--effort", "-"]) == 0  # back to the default
-    assert "deep      opus, effort high\n" in capsys.readouterr().out
+    assert "deep      opus, effort xhigh\n" in capsys.readouterr().out
     assert cli.main(["account", "tier", "max", "balanced", "--model", "-"]) == 0
     assert cli.main(["account", "tier", "max", "fast", "--effort", "low"]) == 0
     assert "fast      haiku, effort low (its own)" in capsys.readouterr().out
@@ -287,7 +287,7 @@ def test_models_of_a_subscription(monkeypatch: pytest.MonkeyPatch, tmp_path: Pat
         == 0
     )
     row = Store(tmp_path / "state" / "lastcall.db").account("claude")
-    assert row is not None and row.account().tiers()["deep"] == ("sonnet", "high")
+    assert row is not None and row.account().tiers()["deep"] == ("sonnet", "xhigh")
     models: Mapping[str, str] = row.models
     assert set(models) == {"fast", "balanced", "deep"}
 
diff --git a/tests/test_lists.py b/tests/test_lists.py
new file mode 100644
index 0000000..fa99f94
--- /dev/null
+++ b/tests/test_lists.py
@@ -0,0 +1,773 @@
+"""Long lists in the web UI. Settings shows the containers of the host and the sources in Loki in three parts, so that
+dozens of them stay short: what lastcall reads now, what it suggests, and the rest in a fold with a filter by name and
+one field to give each a project. The Projects page gets a search by name, filters with their counts, and, with many
+projects, a Run now that starts folded."""
+
+import html
+import re
+from pathlib import Path
+from typing import Any
+
+from lastcall import logs, loki
+from lastcall.recipes.audit import AuditReport
+from lastcall.recipes.improve import ImproveReport
+from lastcall.web import project_views
+from test_loki import FakeLoki
+from test_projects import FakeGitHub
+from test_web import NOW, OTHERS, SITE, Web, help_buttons_inside_a_paragraph, suggest_many
+
+ROOT = Path(__file__).resolve().parents[1]
+PROJECTS = ("acme/shop", "acme/blog", "acme/api", "acme/Worker")
+
+
+# the containers of a host
+
+NOT_MATCHED = "redis:7"
+
+
+def box(name: str, image: str = NOT_MATCHED, compose: str = "", label: str = "") -> dict[str, str]:
+    return {"name": name, "image": image, "state": "running", "compose_project": compose, "label": label}
+
+
+def host() -> list[dict[str, str]]:
+    """A host with dozens of containers: lastcall's own, one with a label, three that match a project, and 30 more."""
+    return [
+        box("lastcall-lastcall-1", "ghcr.io/ne0x86/lastcall-service:0.7.4", "lastcall"),
+        box("lastcall-supervisor-1", "ghcr.io/ne0x86/lastcall-supervisor:0.7.4", "lastcall"),
+        box("proxy-1", "tinyproxy", "lastcall"),  # in lastcall's Compose project, whatever its name
+        box("blog", "nginx:1.27", label="ACME/blog"),
+        box("shop-web-1", "ghcr.io/acme/shop:1.2", "shop"),
+        box("shop-worker-1", "python:3.12", "shop"),
+        box("api-1", "ghcr.io/acme/api:3"),
+        *(box(f"cache-{n:02d}") for n in range(1, 31)),
+    ]
+
+
+def settings_web(tmp_path: Path, listed: list[dict[str, str]] | None = None, **options: Any) -> Web:
+    """A signed-in web UI whose host lists `listed`, with the four projects."""
+    found = host() if listed is None else listed
+    web = Web(tmp_path, containers=lambda: found, **options)
+    web.set_up()
+    for repo in PROJECTS:
+        web.store.add_project(repo)
+    return web
+
+
+def section(page: str, name: str) -> str:
+    """The card of a section of the Settings page: "logs" or "loki"."""
+    return page.split(f'id="{name}">')[1].split("</section>")[0]
+
+
+def part(page: str, kind: str, which: str) -> str:
+    """One of the three parts of a list in the settings: "read", "suggested" or "others"; "" when it is not there."""
+    body = section(page, kind).split("Or with a label in the compose file")[0]  # what follows the lists is not theirs
+    marks = [
+        ("read", f'id="{kind}-read-title"'),
+        ("suggested", f'id="{kind}-suggested-title"'),
+        ("others", '<details class="fold others-fold"'),
+    ]
+    found = [(name, body.index(mark)) for name, mark in marks if mark in body]
+    for number, (name, start) in enumerate(found):
+        if name == which:
+            return body[start : found[number + 1][1] if number + 1 < len(found) else len(body)]
+    return ""
+
+
+def names(piece: str) -> list[str]:
+    """The containers or sources that a part lists: those with a row or a tile of their own."""
+    found = re.findall(r'<strong class="mono">([^<]+)</strong>|class="suggestion-name">([^<]+)</label>', piece)
+    return [row or tile for row, tile in found]
+
+
+def hidden(form: str) -> dict[str, str]:
+    """What a form sends without the owner touching it: its hidden fields."""
+    found = re.findall(r'<input type="hidden" name="([^"]+)" value="([^"]*)">', form)
+    return {name: html.unescape(value) for name, value in found}
+
+
+def row_of(form: dict[str, str], name: str) -> str:
+    """The number of the row that a form of the page gives to a container or a source."""
+    return next(key for key, value in form.items() if value == name).removeprefix("name-")
+
+
+def form_of(piece: str, css: str) -> str:
+    found = re.search(rf'<form method="post" action="[^"]+" class="{css}">(.*?)</form>', piece, re.S)
+    assert found, css
+    return found.group(1)
+
+
+def get(web: Web, path: str = "/settings", lang: str = "en") -> str:
+    return web.client.get(path, headers={"Accept-Language": lang}).get_data(as_text=True)
+
+
+def post(web: Web, path: str, **fields: Any) -> Any:
+    return web.client.post(path, data={"csrf": web.csrf(), **fields}, headers=SITE)
+
+
+def helps(page: str, topic: str) -> int:
+    """How many "?" buttons open the bubble of `topic` (its close button has a popovertarget too)."""
+    return len(re.findall(rf'popovertarget="help-projects-{topic}"(?! popovertargetaction)', page))
+
+
+def clean(page: str) -> None:
+    """What the content security policy would block, and a help button where it must not be."""
+    assert " style=" not in page and "<script" not in page and not re.search(r"\son[a-z]+=", page)
+    assert help_buttons_inside_a_paragraph(page) == []
+
+
+def test_container_logs_come_in_three_parts_and_never_list_lastcalls_own(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    logs.choose(web.store, {"cache-01": "ACME/Api", "cache-02": ""})  # chosen, in another case; and a no
+    page = get(web)
+    card = section(page, "logs")
+    for own in ("lastcall-lastcall-1", "lastcall-supervisor-1", "proxy-1"):
+        assert own not in page  # not by its name, not by its Compose project
+    read, suggested, others = (part(page, "logs", which) for which in ("read", "suggested", "others"))
+    # read now: the label and the choice, with how each was chosen; only a chosen one can stop being read
+    assert names(read) == ["blog", "cache-01"] and ">Read now</h4>" in read
+    assert '<span class="mono">acme/blog</span> <span class="muted">· its label decides</span>' in read
+    assert '<span class="mono">acme/api</span> <span class="muted">· chosen here</span>' in read
+    assert read.count('class="row-actions"') == 1 and 'aria-label="Stop reading cache-01"' in read
+    assert "Stop reading blog" not in read
+    # suggested: a checkbox with the container, and the project that fits
+    assert names(suggested) == ["shop-web-1", "shop-worker-1", "api-1"]
+    assert suggested.count("for acme/shop") == 2 and suggested.count("for acme/api") == 1
+    assert re.findall(r'type="checkbox" name="tick" value="(\d)"', suggested) == ["1", "2", "3"]
+    # the buttons for many at once come first; only "Read the ticked" stays in the bar at the bottom of the screen
+    top, bar = suggested.split('<div class="pick-all">')[1], suggested.split('<div class="pick-bar">')[1]
+    assert 'value="suggested"' in top.split("</div>")[0] and 'value="skip"' in top.split("</div>")[0]
+    assert re.findall(r'name="pick" value="(\w+)"', bar.split("</div>")[0]) == ["selected"]
+    assert ">Read the 3 suggested</button>" in suggested and ">Read the ticked</button>" in suggested
+    # the rest, in a fold that says how many: 29 caches (cache-01 is read), with the one that was said no to
+    assert "<summary>29 other containers</summary>" in others and '<details class="fold others-fold">' in others
+    assert names(others) == [f"cache-{n:02d}" for n in range(2, 31)]
+    assert others.count('list="logs-projects"') == 29 and 'name="logs_q"' in others  # many: a filter by name
+    # one list of projects for the whole section, not one in each row
+    assert card.count("<option") == len(PROJECTS) and "<select" not in card
+    assert card.count('<datalist id="logs-projects">') == 1
+    clean(page)
+    # nothing is read until the owner chooses it: a suggestion is no choice
+    listed = host()
+    assert logs.names_for("acme/shop", listed, logs.chosen(web.store)) == []
+    assert logs.names_for("acme/blog", listed, logs.chosen(web.store)) == ["blog"]
+    assert logs.names_for("acme/api", listed, logs.chosen(web.store)) == ["cache-01"]
+    spanish = get(web, lang="es")
+    assert ">Se lee ahora</h4>" in spanish and ">Sugeridos</h4>" in spanish
+    assert "<summary>29 otros contenedores</summary>" in spanish and "· lo decide su etiqueta" in spanish
+    assert ">Leer los 3 sugeridos</button>" in spanish and ">Dejar de leer</button>" in spanish
+
+
+def test_the_parts_that_have_nothing_to_show_are_short(tmp_path: Path) -> None:
+    web = settings_web(tmp_path, [box("cache-01"), box("cache-02")])
+    page = get(web)
+    assert "Nothing is read yet." in part(page, "logs", "read")
+    assert part(page, "logs", "suggested") == "" and "<summary>2 other containers</summary>" in page
+    assert 'name="logs_q"' not in page  # two: no filter to look for them
+    nothing = settings_web(tmp_path / "none", [box("lastcall-lastcall-1", compose="lastcall")])
+    assert "No containers on this machine besides lastcall&#39;s own." in get(nothing)
+    assert 'class="parts"' not in get(nothing)
+    only = settings_web(tmp_path / "one", [box("shop-web-1", "ghcr.io/acme/shop")])
+    assert ">Read the suggested one</button>" in get(only)
+    assert '<details class="fold others-fold"' not in get(only)  # none left over: no fold
+
+
+def test_the_ticked_suggestions_are_read_or_all_of_them_for_the_project_that_the_page_showed(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    form = hidden(form_of(part(get(web), "logs", "suggested"), "pick"))
+    assert (form["name-1"], form["project-1"], form["name-3"], form["project-3"]) == (
+        "shop-web-1",
+        "acme/shop",
+        "api-1",
+        "acme/api",
+    )
+    response = post(web, "/settings/logs", **{**form, "tick": ["1", "3"], "pick": "selected"})
+    assert response.headers["Location"] == "/settings?done=logs#logs"
+    assert logs.chosen(web.store) == {"shop-web-1": "acme/shop", "api-1": "acme/api"}
+    page = get(web)
+    assert names(part(page, "logs", "read")) == ["blog", "shop-web-1", "api-1"]  # read now, and not suggested again
+    assert names(part(page, "logs", "suggested")) == ["shop-worker-1"]
+    # "all" does not look at what was ticked
+    form = hidden(form_of(part(page, "logs", "suggested"), "pick"))
+    assert post(web, "/settings/logs", **{**form, "tick": ["9"], "pick": "suggested"}).status_code == 302
+    assert logs.chosen(web.store) == {"shop-web-1": "acme/shop", "api-1": "acme/api", "shop-worker-1": "acme/shop"}
+    assert 'id="logs-suggested-title"' not in get(web)  # nothing left to suggest: no such part
+    assert "Saved. lastcall reads the logs of the containers that have a project." in get(web, "/settings?done=logs")
+
+
+def test_ticking_nothing_says_so_and_changes_nothing(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    form = hidden(form_of(part(get(web), "logs", "suggested"), "pick"))
+    for tick in ([], ["7"]):  # none, or a row that the form does not have
+        response = post(web, "/settings/logs", **{**form, "tick": tick, "pick": "selected"})
+        page = response.get_data(as_text=True)
+        assert response.status_code == 400 and "Tick at least one container." in section(page, "logs")
+        assert 'role="alert"' in section(page, "logs") and logs.chosen(web.store) == {}
+    spanish = web.client.post(
+        "/settings/logs",
+        data={"csrf": web.csrf(), **form, "pick": "selected"},
+        headers={**SITE, "Accept-Language": "es"},
+    )
+    assert "Marca al menos un contenedor." in spanish.get_data(as_text=True)
+
+
+def test_skipping_a_suggestion_or_stopping_a_container_says_no_so_that_it_is_not_suggested_again(
+    tmp_path: Path,
+) -> None:
+    web = settings_web(tmp_path)
+    logs.choose(web.store, {"cache-01": "acme/api"})
+    page = get(web)
+    form = hidden(form_of(part(page, "logs", "suggested"), "pick"))
+    assert post(web, "/settings/logs", **{**form, "tick": ["2"], "pick": "skip"}).status_code == 302
+    assert logs.chosen(web.store) == {"cache-01": "acme/api", "shop-worker-1": ""}
+    page = get(web)
+    assert names(part(page, "logs", "suggested")) == ["shop-web-1", "api-1"]
+    assert "shop-worker-1" in names(part(page, "logs", "others")) and "shop-worker-1" not in part(
+        page, "logs", "read"
+    )
+    # Stop reading is a small form of its own: it posts the container and nothing else but the button
+    stop = hidden(form_of(part(page, "logs", "read"), "row-actions"))
+    assert stop == {"csrf": stop["csrf"], "pick": "stop", "name-1": "cache-01"}
+    assert post(web, "/settings/logs", **{k: v for k, v in stop.items() if k != "csrf"}).status_code == 302
+    assert logs.chosen(web.store) == {"cache-01": "", "shop-worker-1": ""}
+    page = get(web)
+    assert names(part(page, "logs", "read")) == ["blog"] and "cache-01" in names(part(page, "logs", "others"))
+    assert logs.names_for("acme/api", host(), logs.chosen(web.store)) == []
+
+
+def test_a_project_typed_for_a_container_is_checked_against_the_projects_whatever_the_case(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    form = hidden(form_of(part(get(web), "logs", "others"), "others-form"))
+    assert form["name-1"] == "cache-01" and form["name-30"] == "cache-30"
+    # the page offers the projects once, to type against; the field says which container it is for
+    assert '<datalist id="logs-projects">' in get(web) and 'aria-label="Project for cache-01"' in get(web)
+    typed = {"project-1": " ACME/blog ", "project-2": "acme/WORKER", "project-3": ""}
+    response = post(web, "/settings/logs", **{**form, **typed, "pick": "others"})
+    assert response.headers["Location"] == "/settings?done=logs#logs"
+    assert logs.chosen(web.store) == {
+        "cache-01": "acme/blog",
+        "cache-02": "acme/Worker",
+    }  # as the Projects page writes them
+    # one that is not a project: nothing is saved, the page says which, and keeps what was typed, with the fold open
+    before = logs.chosen(web.store)
+    wrong = post(
+        web, "/settings/logs", **{**form, "project-4": "acme/shp", "project-5": "acme/API", "pick": "others"}
+    )
+    page = wrong.get_data(as_text=True)
+    assert wrong.status_code == 400 and logs.chosen(web.store) == before
+    assert "“acme/shp” is not one of your projects." in section(page, "logs")
+    fold = part(page, "logs", "others")
+    assert fold.startswith('<details class="fold others-fold" open>') and 'value="acme/shp"' in fold
+    assert 'value="acme/API"' in fold  # what was typed in the others is back: the owner fixes one
+    clean(page)
+    spanish = web.client.post(
+        "/settings/logs",
+        data={"csrf": web.csrf(), **form, "project-4": "acme/shp", "pick": "others"},
+        headers={**SITE, "Accept-Language": "es"},
+    )
+    assert "«acme/shp» no es uno de tus proyectos." in spanish.get_data(as_text=True)
+    # what the owner typed is the owner's own: escaped, and given back no longer than a repository's name
+    odd = post(web, "/settings/logs", **{**form, "project-6": "<b>x</b>", "project-7": "x" * 300, "pick": "others"})
+    page = odd.get_data(as_text=True)
+    assert odd.status_code == 400 and "&lt;b&gt;x&lt;/b&gt;" in page and "<b>x</b>" not in page
+    assert f'value="{"x" * 140}"' in page and "x" * 141 not in page
+    clean(page)
+
+
+def test_the_other_containers_are_filtered_by_name_from_the_address(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    page = get(web, "/settings?logs_q=CACHE-1&loki_q=zz")  # whatever the case
+    fold = part(page, "logs", "others")
+    assert fold.startswith('<details class="fold others-fold" open>')  # a filter that is set: no match is hidden
+    assert names(fold) == [f"cache-{n}" for n in range(10, 20)]
+    assert "10 of 30 match “CACHE-1”." in fold and '<a href="/settings?loki_q=zz#logs">Show all</a>' in fold
+    assert '<form method="get" action="/settings#logs" class="filter" role="search">' in fold
+    assert 'name="logs_q" type="search" value="CACHE-1"' in fold
+    assert '<input type="hidden" name="loki_q" value="zz">' in fold  # the other list's filter stays
+    assert "<summary>30 other containers</summary>" in fold  # it says how many there are, not how many match
+    # the save form holds only the rows that show, so that saving cannot touch the others
+    assert hidden(form_of(fold, "others-form")) == {
+        "csrf": hidden(form_of(fold, "others-form"))["csrf"],
+        **{f"name-{n + 1}": f"cache-{10 + n}" for n in range(10)},
+    }
+    nothing = get(web, "/settings?logs_q=zzz")
+    assert "0 of 30 match “zzz”." in nothing and 'class="others-form"' not in nothing
+    assert 'name="logs_q" type="search" value="zzz"' in nothing  # the filter stays, to be cleared
+    trimmed = get(web, "/settings?logs_q=%20%20cache-3%20")
+    assert "1 of 30 match “cache-3”." in trimmed and 'value="cache-3"' in trimmed
+    long = get(web, "/settings?logs_q=" + "x" * 300)
+    assert f'value="{"x" * 100}"' in long
+    odd = get(web, "/settings?logs_q=%3Cb%3Ex%3C/b%3E")
+    assert "&lt;b&gt;x&lt;/b&gt;" in odd and "<b>x</b>" not in odd
+    assert "10 de 30 coinciden con «CACHE-1»." in get(web, "/settings?logs_q=CACHE-1", "es")
+    assert "1 of 30 matches" not in get(web)  # no filter, no note
+
+
+def test_the_filter_shows_from_the_seventh_other_container_or_while_one_is_set(tmp_path: Path) -> None:
+    few = settings_web(tmp_path, [box(f"cache-{n}") for n in range(1, 7)])
+    assert 'name="logs_q"' not in get(few)  # six
+    assert 'name="logs_q" type="search" value="1"' in get(few, "/settings?logs_q=1")  # set: it shows, to be cleared
+    seven = settings_web(tmp_path / "seven", [box(f"cache-{n}") for n in range(1, 8)])
+    assert 'name="logs_q"' in get(seven)
+
+
+def test_a_choice_for_a_removed_project_survives_every_save_and_comes_back_with_the_project(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    logs.choose(web.store, {"cache-01": "acme/gone", "shop-web-1": "acme/shop"})
+    note = "It was chosen for acme/gone, which is not a project now: add acme/gone again and it is read again."
+    page = get(web)
+    assert part(page, "logs", "others").count(note) == 1 and "cache-01" in names(part(page, "logs", "others"))
+    assert "cache-01" not in part(page, "logs", "read") and 'value="acme/gone"' not in page
+    # saving the others as the page sends them (nothing typed) changes nothing; typing for another one keeps it too
+    form = hidden(form_of(part(page, "logs", "others"), "others-form"))
+    assert post(web, "/settings/logs", **{**form, "pick": "others"}).status_code == 302
+    assert logs.chosen(web.store) == {"cache-01": "acme/gone", "shop-web-1": "acme/shop"}
+    row = next(k for k, v in form.items() if v == "cache-05").removeprefix("name-")
+    assert post(web, "/settings/logs", **{**form, f"project-{row}": "acme/blog", "pick": "others"}).status_code == 302
+    assert logs.chosen(web.store) == {"cache-01": "acme/gone", "cache-05": "acme/blog", "shop-web-1": "acme/shop"}
+    # the other forms never touch it either
+    assert post(web, "/settings/logs", **{"name-1": "shop-web-1", "pick": "stop"}).status_code == 302
+    assert logs.chosen(web.store)["cache-01"] == "acme/gone"
+    # the project is back: so is the container, read now, with nothing to say about it
+    web.store.add_project("acme/gone")
+    page = get(web)
+    assert "cache-01" in names(part(page, "logs", "read")) and "is not a project now" not in page
+    assert '<span class="mono">acme/gone</span> <span class="muted">· chosen here</span>' in page
+    assert logs.names_for("acme/gone", host(), logs.chosen(web.store)) == ["cache-01"]
+
+
+def test_a_label_wins_over_a_choice_and_may_name_a_project_that_does_not_exist_yet(tmp_path: Path) -> None:
+    web = settings_web(tmp_path, [box("blog", label="ACME/blog"), box("site", label="acme/missing")])
+    logs.choose(web.store, {"blog": "acme/shop", "site": "acme/shop"})  # the label decides, not this
+    page = get(web)
+    read = part(page, "logs", "read")
+    assert names(read) == ["blog", "site"] and read.count("its label decides") == 2
+    assert '<span class="mono">acme/blog</span>' in read and "acme/shop" not in read  # as the Projects page writes it
+    assert "Its label names acme/missing, which is not a project: add it on the Projects page and it is read." in read
+    assert read.count('class="row-actions"') == 0  # nothing to stop: the label is in the app's compose file
+    assert part(page, "logs", "suggested") == "" and "other containers" not in page
+    assert logs.names_for("acme/blog", [box("blog", label="ACME/blog")], {"blog": "acme/shop"}) == ["blog"]
+
+
+def test_the_forms_of_the_container_list_refuse_what_the_page_never_sends(tmp_path: Path) -> None:
+    web = settings_web(tmp_path)
+    form = hidden(form_of(part(get(web), "logs", "suggested"), "pick"))
+    forged: list[dict[str, Any]] = [
+        {"name-1": "../etc/passwd", "pick": "stop"},  # not a container's name
+        {"name-1": "lastcall-step-abc123", "pick": "stop"},  # what an agent printed: never read
+        {
+            **form,
+            "project-1": "someone/else",
+            "tick": ["1"],
+            "pick": "selected",
+        },  # a suggestion that is not a project
+        {"name-1": "cache-01", "project-1": "acme/blog", "name-2": "a b", "pick": "others"},
+    ]
+    for fields in forged:
+        response = post(web, "/settings/logs", **fields)
+        assert response.status_code == 400 and "Some values in this form are not valid" in response.get_data(
+            as_text=True
+        )
+        assert logs.chosen(web.store) == {}
+    plain = {k: v for k, v in form.items() if k != "csrf"}
+    unsigned = web.client.post("/settings/logs", data={**plain, "tick": ["1"], "pick": "selected"}, headers=SITE)
+    assert unsigned.status_code == 403  # no CSRF token
+    elsewhere = web.client.post(
+        "/settings/logs",
+        data={"csrf": web.csrf(), **form, "tick": ["1"], "pick": "selected"},
+        headers={"Origin": "https://evil.example"},
+    )
+    assert elsewhere.status_code == 403 and logs.chosen(web.store) == {}
+    stranger = web.app.test_client().post("/settings/logs", data={**form, "pick": "suggested"}, headers=SITE)
+    assert stranger.status_code == 302 and stranger.headers["Location"] == "/login"
+    assert logs.chosen(web.store) == {}
+
+
+# the sources in Loki
+
+SERIES = [
+    {"container": "lastcall-lastcall-1", "compose_project": "lastcall", "host": "vps-1"},  # lastcall's own
+    {"container": "shop-web-1", "compose_project": "shop", "host": "vps-1"},
+    {"container": "shop-web-1", "compose_project": "shop", "host": "vps-2"},
+    {"container": "api-1", "compose_project": "api", "host": "vps-1"},
+    {"container": "blog-1", "compose_project": "blog", "host": "vps-3"},
+    *({"container": f"job-{n:02d}", "host": "vps-3"} for n in range(1, 11)),
+]
+
+
+def loki_web(tmp_path: Path, series: list[dict[str, str]] | None = None) -> Web:
+    """A signed-in web UI connected to a Loki that has `series`, with the four projects."""
+    web = Web(tmp_path, loki_fetch=FakeLoki(SERIES if series is None else series))
+    web.set_up()
+    loki.Loki("http://loki.example.com:3100").save(web.secrets)
+    web.store.set_setting(loki.LABEL, "container")
+    for repo in PROJECTS:
+        web.store.add_project(repo)
+    return web
+
+
+def test_sources_in_loki_come_in_the_same_three_parts_with_their_hosts_and_compose_project(tmp_path: Path) -> None:
+    web = loki_web(tmp_path)
+    loki.choose(web.store, {"blog-1": "acme/blog"})
+    page = get(web)
+    card = section(page, "loki")
+    assert "lastcall-lastcall-1" not in card  # lastcall's own, by its Compose project and by its name
+    read, suggested, others = (part(page, "loki", which) for which in ("read", "suggested", "others"))
+    assert names(read) == ["blog-1"] and '<span class="chip">vps-3</span>' in read
+    assert "Compose project: blog" in read and 'aria-label="Stop reading blog-1"' in read
+    assert names(suggested) == ["api-1", "shop-web-1"]  # Loki's sources come sorted by name
+    assert '<span class="chip">vps-1</span> <span class="chip">vps-2</span>' in suggested  # where it ran
+    assert "Compose project: shop" in suggested and "for acme/shop" in suggested and "for acme/api" in suggested
+    assert "<summary>10 other sources</summary>" in others and names(others) == [f"job-{n:02d}" for n in range(1, 11)]
+    assert others.count('list="loki-projects"') == 10 and 'name="loki_q"' in others
+    # the label that names the sources stays, and every form says it: the choices belong to it
+    assert '<option value="container" selected>container</option>' in card
+    for piece in (read, suggested, others):
+        assert re.search(r'<input type="hidden" name="label" value="container">', piece)
+    assert card.count("<option") == len(PROJECTS) + 3  # the projects, once, and the 3 labels that Loki has
+    assert card.count("<select") == 1  # only the label's own: no select of projects in any row
+    clean(page)
+    spanish = get(web, lang="es")
+    assert "<summary>10 otras fuentes</summary>" in spanish and "para acme/shop" in spanish
+
+
+def test_the_forms_of_the_sources_read_the_ticked_or_all_skip_stop_and_check_the_project(tmp_path: Path) -> None:
+    web = loki_web(tmp_path)
+    form = hidden(form_of(part(get(web), "loki", "suggested"), "pick"))
+    assert form["label"] == "container" and form["name-1"] == "api-1" and form["project-1"] == "acme/api"
+    shop = row_of(form, "shop-web-1")
+    assert form[f"project-{shop}"] == "acme/shop"
+    response = post(web, "/settings/loki/sources", **{**form, "tick": [shop], "pick": "selected"})
+    assert response.headers["Location"] == "/settings?done=loki_sources#loki"
+    assert (web.store.setting(loki.LABEL), loki.chosen(web.store)) == ("container", {"shop-web-1": "acme/shop"})
+    form = hidden(form_of(part(get(web), "loki", "suggested"), "pick"))
+    assert post(web, "/settings/loki/sources", **{**form, "pick": "suggested"}).status_code == 302  # api-1 and blog-1
+    assert loki.chosen(web.store) == {"api-1": "acme/api", "blog-1": "acme/blog", "shop-web-1": "acme/shop"}
+    assert names(part(get(web), "loki", "read")) == ["api-1", "blog-1", "shop-web-1"]
+    stop = {k: v for k, v in hidden(form_of(part(get(web), "loki", "read"), "row-actions")).items() if k != "csrf"}
+    assert stop["pick"] == "stop" and stop["label"] == "container" and stop["name-1"] == "api-1"
+    assert post(web, "/settings/loki/sources", **stop).status_code == 302
+    assert loki.chosen(web.store) == {"api-1": "", "blog-1": "acme/blog", "shop-web-1": "acme/shop"}
+    # a project typed in the others, in any case
+    others = hidden(form_of(part(get(web), "loki", "others"), "others-form"))
+    first, second = row_of(others, "job-01"), row_of(others, "job-02")
+    typed = {**others, f"project-{first}": "ACME/worker", "pick": "others"}
+    assert post(web, "/settings/loki/sources", **typed).status_code == 302
+    assert loki.chosen(web.store)["job-01"] == "acme/Worker"
+    wrong = post(web, "/settings/loki/sources", **{**others, f"project-{second}": "acme/nope", "pick": "others"})
+    page = wrong.get_data(as_text=True)
+    assert wrong.status_code == 400 and "“acme/nope” is not one of your projects." in section(page, "loki")
+    assert part(page, "loki", "others").startswith('<details class="fold others-fold" open>')
+    assert 'value="acme/nope"' in part(page, "loki", "others") and "job-02" not in loki.chosen(web.store)
+    none = post(web, "/settings/loki/sources", **{**others, "tick": [], "pick": "selected"})
+    assert none.status_code == 400 and "Tick at least one source." in none.get_data(as_text=True)
+    # the label that the form says is the one that its choices belong to: another starts again
+    assert post(web, "/settings/loki/sources", **{**others, "label": "job", "pick": "others"}).status_code == 302
+    assert (web.store.setting(loki.LABEL), loki.chosen(web.store)) == ("job", {})
+
+
+def test_the_forms_of_the_sources_refuse_what_the_page_never_sends(tmp_path: Path) -> None:
+    web = loki_web(tmp_path)
+    form = hidden(form_of(part(get(web), "loki", "suggested"), "pick"))
+    for bad in (
+        {"name-1": "lastcall-step-abc123"},  # a step of lastcall's
+        {"project-1": "someone/else", "tick": ["1"], "pick": "selected"},
+        {"label": "a b"},
+        {"label": ""},
+    ):
+        response = post(web, "/settings/loki/sources", **{**form, "tick": ["1"], "pick": "selected", **bad})
+        assert response.status_code == 400, bad
+    assert loki.chosen(web.store) == {}
+
+
+def test_the_sources_are_filtered_by_name_too(tmp_path: Path) -> None:
+    web = loki_web(tmp_path)
+    page = get(web, "/settings?loki_q=JOB-0&logs_q=zz")
+    fold = part(page, "loki", "others")
+    assert fold.startswith('<details class="fold others-fold" open>') and len(names(fold)) == 9
+    assert "9 of 10 match “JOB-0”." in fold and '<a href="/settings?logs_q=zz#loki">Show all</a>' in fold
+    assert '<input type="hidden" name="logs_q" value="zz">' in fold
+    assert 'name="loki_q" type="search" value="JOB-0"' in fold
+    assert "9 de 10 coinciden con «JOB-0»." in get(web, "/settings?loki_q=JOB-0", "es")
+
+
+def test_a_loki_with_nothing_but_lastcalls_own_sources_says_it_saw_none(tmp_path: Path) -> None:
+    web = loki_web(tmp_path, [{"container": "lastcall-lastcall-1", "compose_project": "lastcall", "host": "vps-1"}])
+    page = get(web)
+    assert "Loki saw no streams with this label in the last 7 days." in page and 'class="parts"' not in page
+
+
+# the Projects page
+
+
+def projects_web(tmp_path: Path) -> Web:
+    """Nine projects, with the GitHub App and an account: three are off, and three wait for the owner (a pull request
+    to review, a decision in an issue, ideas to choose in a plan)."""
+    web = Web(tmp_path, github=FakeGitHub())
+    web.set_up()
+    web.store.add_account("claude", "claude-code")
+    for name in ("api-gateway", "web", "worker", "billing", "Admin", "reports"):
+        web.store.add_project(f"acme/{name}")
+    for name in ("api-docs", "legacy", "mobile"):
+        web.store.add_project(f"acme/{name}", active=False)
+    finding = {"title": "T", "severity": "high", "file": "a.py", "lines": "1", "why": "w", "fix": "f"}
+    report = AuditReport("acme/web", "a2051bd", "claude-code", "English")
+    report.findings = [{**finding, "id": "B1"}]
+    report.verdicts = [{"id": "B1", "verdict": "valid", "decision": "pr"}]
+    report.deliveries = [
+        {"status": "opened", "url": "https://github.com/acme/web/pull/7", "title": "T", "ids": ["B1"]}
+    ]
+    web.store.start_run("r-web", "acme/web", "claude", "burst")
+    web.store.record_findings("r-web", report)
+    web.store.record_deliveries("r-web", report)
+    web.store.finish_run("r-web", "ok", "a2051bd")
+    report = AuditReport("acme/billing", "b3162ce", "claude-code", "English")
+    report.findings = [{**finding, "id": "B2"}]
+    report.verdicts = [{"id": "B2", "verdict": "valid", "decision": "issue"}]
+    report.issue_url = "https://github.com/acme/billing/issues/3"
+    web.store.start_run("r-billing", "acme/billing", "claude", "burst")
+    web.store.record_findings("r-billing", report)
+    web.store.record_deliveries("r-billing", report)
+    web.store.finish_run("r-billing", "ok", "b3162ce")
+    plan = ImproveReport("acme/mobile", "abc", "claude-code", "English")
+    plan.ideas = [{"id": "I1", "title": "A", "kind": "feature", "change": "c"}]
+    plan.verdicts = [{"id": "I1", "verdict": "keep"}]
+    plan.plan, plan.issue_url = ["I1"], "https://github.com/acme/mobile/issues/4"
+    web.store.record_ideas("r-mobile", plan)
+    return web
+
+
+def cards(page: str) -> list[str]:
+    """The projects whose cards the page shows, in order."""
+    return re.findall(r'<article class="card project(?: is-off)?" id="project-([^"]+)"', page)
+
+
+def filters(page: str) -> list[tuple[str, str, str, bool]]:
+    """The filter links: where each goes, its name, its count and whether it is marked as the current one."""
+    found = re.findall(
+        r'<li><a href="([^"]*)"( aria-current="true")?>([^<]+) <span class="count">(\d+)</span></a></li>', page
+    )
+    return [(html.unescape(href), name, count, bool(current)) for href, current, name, count in found]
+
+
+def test_the_projects_page_searches_by_name_and_filters_with_counts(tmp_path: Path) -> None:
+    web = projects_web(tmp_path)
+    page = get(web, "/projects")
+    assert len(cards(page)) == 9 and 'role="search"' in page and 'for="search">Search by name</label>' in page
+    assert filters(page) == [
+        ("/projects#find", "All", "9", True),
+        ("/projects?show=active#find", "Active", "6", False),
+        ("/projects?show=inactive#find", "Inactive", "3", False),
+        ("/projects?show=waiting#find", "Waiting for you", "3", False),
+    ]
+    assert '<nav class="find-links" aria-label="Show projects">' in page and "Showing" not in page
+    assert '<form method="get" action="/projects#find" class="filter" role="search">' in page
+    assert 'id="search" name="search" type="search" value=""' in page and ">Search</button>" in page
+    # the filters, each with the projects that it leaves
+    for show, found in {
+        "active": ["api-gateway", "web", "worker", "billing", "Admin", "reports"],
+        "inactive": ["api-docs", "legacy", "mobile"],
+        "waiting": ["web", "billing", "mobile"],  # a pull request, a decision, ideas
+    }.items():
+        shown = cards(get(web, f"/projects?show={show}"))
+        assert sorted(shown, key=str.lower) == sorted((f"acme--{n}" for n in found), key=str.lower), show
+    page = get(web, "/projects?show=waiting")
+    assert [f[3] for f in filters(page)] == [False, False, False, True] and "Showing 3 of 9 projects." in page
+    # the search looks in the name, whatever the case, and the counts are those of the search
+    page = get(web, "/projects?search=API")
+    assert sorted(cards(page)) == ["acme--api-docs", "acme--api-gateway"]
+    assert [(f[1], f[2]) for f in filters(page)] == [
+        ("All", "2"),
+        ("Active", "1"),
+        ("Inactive", "1"),
+        ("Waiting for you", "0"),
+    ]
+    assert 'name="search" type="search" value="API"' in page and "Showing 2 of 9 projects." in page
+    assert cards(get(web, "/projects?search=acme/ADMIN")) == ["acme--Admin"]  # the whole name, owner included
+    # search and filter combine, and each link keeps the search
+    page = get(web, "/projects?search=api&show=active")
+    assert cards(page) == ["acme--api-gateway"] and "Showing 1 of 9 projects." in page
+    assert filters(page) == [
+        ("/projects?search=api#find", "All", "2", False),
+        ("/projects?show=active&search=api#find", "Active", "1", True),
+        ("/projects?show=inactive&search=api#find", "Inactive", "1", False),
+        ("/projects?show=waiting&search=api#find", "Waiting for you", "0", False),
+    ]
+    assert '<input type="hidden" name="show" value="active">' in page  # a new search keeps the filter
+    # both stay at the cards: the forms and the links go back to the bar, and nothing is a script or a style
+    clean(page)
+    spanish = get(web, "/projects?show=waiting&search=a", "es")
+    assert 'for="search">Buscar por nombre</label>' in spanish and 'aria-label="Mostrar proyectos"' in spanish
+    assert "Pendientes de ti" in spanish and "Mostrando 3 de 9 proyectos." in spanish
+    assert [f[1] for f in filters(spanish)] == ["Todos", "Activos", "Inactivos", "Pendientes de ti"]
+
+
+def test_no_project_matching_has_its_own_message_and_the_page_goes_on(tmp_path: Path) -> None:
+    web = projects_web(tmp_path)
+    page = get(web, "/projects?search=zzz")
+    assert cards(page) == [] and "No project matches this search and filter." in page
+    assert '<a href="/projects#find">Show all projects</a>' in page
+    assert "No projects yet." not in page and 'id="add-title"' in page  # it is not an empty page: the Add part stays
+    assert 'name="search" type="search" value="zzz"' in page and "Showing 0 of 9 projects." in page
+    empty = get(web, "/projects?show=waiting&search=reports")  # a project that waits for nothing
+    assert cards(empty) == [] and "No project matches" in empty and "Showing 0 of 9" in empty
+    assert "Ningún proyecto coincide con esta búsqueda y este filtro." in get(web, "/projects?search=zzz", "es")
+    assert "No project matches" not in get(web, "/projects")
+    none = Web(tmp_path / "none", github=FakeGitHub())
+    none.set_up()
+    assert "No projects yet." in get(none, "/projects") and "No project matches" not in get(
+        none, "/projects?search=a"
+    )
+    assert 'role="search"' not in get(none, "/projects")
+
+
+def test_what_waits_for_the_owner_is_what_the_dashboard_lists(tmp_path: Path) -> None:
+    web = projects_web(tmp_path)
+    assert project_views.waiting_for_the_owner(web.store) == {"acme/web", "acme/billing", "acme/mobile"}
+    web.store.close_pr("https://github.com/acme/web/pull/7", merged=True)  # reviewed
+    web.store.close_issue("https://github.com/acme/billing/issues/3", completed=True)  # decided
+    assert project_views.waiting_for_the_owner(web.store) == {"acme/mobile"}
+    assert cards(get(web, "/projects?show=waiting")) == ["acme--mobile"]
+    assert [(f[1], f[2]) for f in filters(get(web, "/projects"))][3] == ("Waiting for you", "1")
+
+
+def test_the_search_and_the_filters_show_from_the_seventh_project_or_while_one_is_set(tmp_path: Path) -> None:
+    web = Web(tmp_path, github=FakeGitHub())
+    web.set_up()
+    for name in "abcdef":
+        web.store.add_project(f"acme/{name}")
+    page = get(web, "/projects")
+    assert len(cards(page)) == 6 and 'id="find"' not in page and "find-links" not in page  # six: no bar
+    assert 'id="find"' in get(web, "/projects?search=a") and 'id="find"' in get(web, "/projects?show=active")
+    assert 'id="find"' not in get(web, "/projects?show=bogus")  # a value that is none of them is the default
+    web.store.add_project("acme/g")
+    page = get(web, "/projects")
+    assert len(cards(page)) == 7 and 'id="find"' in page and filters(page)[0][3] is True
+    odd = get(web, "/projects?show=%3Cb%3E&search=%3Cb%3Ex%3C/b%3E")
+    assert "&lt;b&gt;x&lt;/b&gt;" in odd and "<b>x</b>" not in odd and filters(odd)[0][3] is True
+    assert f'value="{"x" * 100}"' in get(web, "/projects?search=" + "x" * 300)
+
+
+def get_form(page: str, action: str) -> str:
+    """The inside of the GET form that goes to `action` (a filter or a search)."""
+    return page.split(f'<form method="get" action="{action}"')[1].split("</form>")[0]
+
+
+def test_the_filter_of_the_suggestions_and_the_search_of_the_cards_keep_each_other(tmp_path: Path) -> None:
+    web = projects_web(tmp_path)
+    # acme/web and acme/worker are projects already: seven suggestions are left, so that their filter shows
+    suggest_many(web.store, others=(*OTHERS, "acme/extra", "acme/more"))
+    plain = get(web, "/projects")
+    assert "hidden" not in get_form(plain, "/projects#find") and "hidden" not in get_form(
+        plain, "/projects#suggestions"
+    )
+    assert '<a href="/projects#suggestions">Show all</a>' not in plain  # no filter, no note
+    page = get(web, "/projects?search=api&show=active&q=web")
+    # a new search keeps the filter of the suggestions, and the new filter of the suggestions keeps the search and the
+    # filter of the cards
+    assert '<input type="hidden" name="q" value="web">' in get_form(page, "/projects#find")
+    assert '<input type="hidden" name="show" value="active">' in get_form(page, "/projects#find")
+    assert (
+        '<input type="hidden" name="search" value="api"><input type="hidden" name="show" value="active">'
+        in get_form(page, "/projects#suggestions")
+    )
+    assert filters(page) == [
+        ("/projects?search=api&q=web#find", "All", "2", False),
+        ("/projects?show=active&search=api&q=web#find", "Active", "1", True),
+        ("/projects?show=inactive&search=api&q=web#find", "Inactive", "1", False),
+        ("/projects?show=waiting&search=api&q=web#find", "Waiting for you", "0", False),
+    ]
+    assert '<a href="/projects?search=api&amp;show=active#suggestions">Show all</a>' in page
+    only_cards = get(web, "/projects?show=waiting")
+    assert '<a href="/projects?show=waiting#find"' in only_cards and "q=" not in "".join(
+        f[0] for f in filters(only_cards)
+    )
+    only_suggestions = get(web, "/projects?q=web")
+    assert '<a href="/projects#suggestions">Show all</a>' in only_suggestions
+    assert next(f[0] for f in filters(only_suggestions)) == "/projects?q=web#find"
+
+
+def test_with_more_than_six_projects_each_cards_run_now_starts_folded(tmp_path: Path) -> None:
+    web = projects_web(tmp_path)
+    page = get(web, "/projects")
+    assert page.count('<details class="fold run-fold">') == 9  # closed: no open attribute
+    card = page.split('id="project-acme--web"')[1].split("</article>")[0]
+    fold = card.split('<details class="fold run-fold">')[1].split("</details>")[0]
+    assert fold.startswith("\n        <summary>Run now</summary>")  # its title is what opens it
+    assert 'action="/projects/acme/web/audit"' in fold and ">Audit now</button>" in fold  # the form is inside
+    assert 'action="/projects/acme/web/improve"' in fold and "<legend>Run now</legend>" not in card
+    assert 'aria-label="Run now"' in fold and "Starts a run right away, on the account you choose." in fold
+    # the card keeps its Settings fold, after the Run now one
+    assert card.index("run-fold") < card.index("<summary>Settings</summary>")
+    # a "?" inside a fold repeats, so that each card reaches its help; each bubble is there once
+    for bubble in ("run_now", "account", "improve"):
+        assert helps(page, bubble) == 9, bubble
+        assert page.count(f'id="help-projects-{bubble}" popover') == 1, bubble
+    clean(page)
+    assert "<summary>Ejecutar ahora</summary>" in get(web, "/projects", "es")
+    # an order that waits shows its message, as before, instead of a form to fold
+    web.store.add_order("audit", "acme/web", None, NOW)
+    page = get(web, "/projects")
+    assert page.count('<details class="fold run-fold">') == 8 and "Audit queued: it starts as soon as" in page
+
+
+def test_with_six_projects_or_fewer_run_now_is_open_as_it_was(tmp_path: Path) -> None:
+    web = Web(tmp_path, github=FakeGitHub())
+    web.set_up()
+    web.store.add_account("claude", "claude-code")
+    for name in "abcdef":
+        web.store.add_project(f"acme/{name}")
+    page = get(web, "/projects")
+    assert "run-fold" not in page and page.count("<legend>Run now</legend>") == 6
+    assert page.count('<fieldset class="run-now has-help">') == 6
+    assert helps(page, "run_now") == 1  # once for the page, on the first card
+    clean(page)
+    web.store.add_project("acme/g")
+    assert get(web, "/projects").count('<details class="fold run-fold">') == 7
+
+
+# the stylesheet and the documents
+
+
+def test_the_new_rules_sit_in_their_own_blocks_of_the_stylesheet() -> None:
+    css = (ROOT / "src/lastcall/web/static/style.css").read_text(encoding="utf-8")
+    projects = css.split("Projects: the page header")[1].split("/* ---------- Sign-in pages")[0]
+    for rule in (".find {", ".find-links a[aria-current]", ".find-links .count", ".run-fold > .run-form"):
+        assert rule in projects, rule
+    rows = css.split("/* ---------- Lists of rows")[1].split("/* ---------- Settings ----------")[0]
+    for rule in (".parts {", "ul.reading > li", ".read-main {", "ul.others > li", ".others-form {", ".part-title {"):
+        assert rule in rows, rule
+    # the rows of a section are flex or grid items that wrap: never wider than a phone's screen
+    assert "ul.reading > li { display: flex; flex-wrap: wrap;" in rows
+    assert not re.search(
+        r"\sstyle=|<style", (ROOT / "src/lastcall/web/templates/_lists.html").read_text(encoding="utf-8")
+    )
+
+
+def test_the_documents_describe_the_lists_that_scale() -> None:
+    readme = " ".join((ROOT / "README.md").read_text(encoding="utf-8").split())
+    design = " ".join((ROOT / "DESIGN.md").read_text(encoding="utf-8").split())
+    logs_text = readme.split("**Container logs.**")[1].split("**Logs in Loki.**")[0]
+    loki_text = readme.split("**Logs in Loki.**")[1].split("**After the merge.**")[0]
+    for text in (logs_text, loki_text):
+        assert "Read now" in text and "suggested" in text and "fold" in text
+    assert "lastcall's own containers never show" in logs_text
+    web_ui = design.split("## 13. Web UI and CLI")[1].split("## 14. Extensibility")[0]
+    for words in (
+        "`Read now`",
+        "`POST /settings/logs`",
+        "`POST /settings/loki/sources`",
+        "`logs_q`",
+        "`loki_q`",
+        "`<datalist>`",
+        "ignoring case",
+        "`#find`",
+        "`search`",
+        "`show`",
+        "starts folded",
+    ):
+        assert words in web_ui, words
+    # the parameters and the anchor that they name exist
+    source = (ROOT / "src/lastcall/web/__init__.py").read_text(encoding="utf-8")
+    assert all(f'"{name}"' in source for name in ("logs_q", "loki_q", "search", "show"))
+    assert 'id="find"' in (ROOT / "src/lastcall/web/templates/projects.html").read_text(encoding="utf-8")
+    assert '"/settings/logs"' in source and '"/settings/loki/sources"' in source
diff --git a/tests/test_logs.py b/tests/test_logs.py
index c569d4c..080773e 100644
--- a/tests/test_logs.py
+++ b/tests/test_logs.py
@@ -247,3 +247,110 @@ def test_the_settings_page_shows_a_choice_as_its_project_is_written_and_keeps_ap
     assert logs.shown("ACME/BLOG", repos) == ("acme/Blog", "")  # the command line takes the project in any case
     assert logs.shown("acme/old", repos) == ("", "acme/old")  # the owner removed that project: kept, and shown apart
     assert logs.shown("", repos) == ("", "")  # no choice, or a no
+
+
+# the settings page's lists: containers in three parts, and what its forms ask
+
+
+def test_lastcalls_own_containers_are_those_of_its_compose_project_or_named_lastcall() -> None:
+    assert logs.is_own(container("lastcall-lastcall-1", compose="lastcall"))
+    assert logs.is_own(container("lastcall-supervisor-1"))  # by its name
+    assert logs.is_own(container("proxy-1", compose="Lastcall"))  # by its Compose project, in any case
+    assert logs.is_own({"name": "LASTCALL-egress-1"})
+    assert not logs.is_own(container("lastcall", compose="shop"))  # an app that is called so is not lastcall's
+    assert not logs.is_own(container("shop-lastcall-1", compose="shop"))
+    assert not logs.is_own({})
+
+
+def test_containers_come_in_three_parts_and_lastcalls_own_are_in_none() -> None:
+    repos = ["acme/shop", "acme/Blog", "acme/api"]
+    listed = [
+        container("shop-web-1", "ghcr.io/acme/shop:1.2", "shop"),  # a suggestion: it is not a choice
+        container("blog", label="ACME/blog"),  # read by its label, as the Projects page writes the project
+        container("site", label="acme/missing"),  # a label that names no project: read once it is one
+        container("api-1", "x"),  # chosen, in another case
+        container("redis", "redis:7"),  # nothing fits
+        container("old", "x"),  # chosen for a project that was removed
+        container("nope", "ghcr.io/acme/shop"),  # the owner said no to its suggestion
+        container("lastcall-lastcall-1", "ghcr.io/ne0x86/lastcall-service:0.7.4", "lastcall"),
+        container("proxy-1", compose="lastcall"),
+    ]
+    choices = {"api-1": "ACME/API", "old": "acme/gone", "nope": "", "blog": "acme/shop"}  # a label wins over a choice
+    found = logs.parts(listed, repos, choices)
+    assert [(r["name"], r["project"], r["by"], r["unknown"]) for r in found.read if r["by"] == "label"] == [
+        ("blog", "acme/Blog", "label", False),
+        ("site", "acme/missing", "label", True),
+    ]
+    assert [(r["name"], r["project"], r["by"]) for r in found.read if r["by"] == "choice"] == [
+        ("api-1", "acme/api", "choice")
+    ]
+    assert [(s["name"], s["suggested"]) for s in found.suggested] == [("shop-web-1", "acme/shop")]
+    assert [(o["name"], o["suggested"], o["gone"]) for o in found.others] == [
+        ("redis", "", ""),
+        ("old", "", "acme/gone"),  # the choice is kept, and shown apart
+        ("nope", "", ""),
+    ]
+    assert found.count == 7 and [o["name"] for o in found.others_named("O")] == ["old", "nope"]
+    assert [o["name"] for o in found.others_named("rEd")] == ["redis"] and found.others_named("zzz") == []
+    assert found.others_named("") == found.others
+    # sources in Loki have no label: the same function sorts them
+    sources = [{"name": "shop-web-1", "compose_project": "shop", "hosts": ["vps-1"]}, {"name": "job-1", "hosts": []}]
+    assert [s["name"] for s in logs.parts(sources, repos, {}).suggested] == ["shop-web-1"]
+
+
+def test_a_project_is_the_one_that_the_projects_page_writes_whatever_the_case_typed() -> None:
+    repos = ["acme/shop", "acme/Blog"]
+    assert (
+        logs.project_named("acme/blog", repos) == "acme/Blog"
+        and logs.project_named(" ACME/SHOP ", repos) == "acme/shop"
+    )
+    assert logs.project_named("acme/blo", repos) is None and logs.project_named("", repos) is None
+    assert logs.project_named("shop", repos) is None  # the whole name: no guessing
+
+
+def form_choices(
+    form: dict[str, str], ticked: tuple[str, ...] = (), choices: dict[str, str] | None = None
+) -> dict[str, str]:
+    """What `logs.apply_form` makes of a form for containers that are named by letters and digits only, with the
+    projects `acme/shop` and `acme/Blog`."""
+    return logs.apply_form(form, ticked, choices or {}, ["acme/shop", "acme/Blog"], lambda name: name.isalnum())
+
+
+def test_a_form_of_the_settings_page_changes_the_choices_that_its_button_asks_for() -> None:
+    rows = {"name-1": "web", "project-1": "acme/shop", "name-2": "worker", "project-2": "acme/blog"}
+    kept = {"cache": "acme/shop", "old": "acme/gone"}
+    # the ticked ones, or all of them, for the project that the page showed, written as the Projects page writes it
+    assert form_choices({**rows, "pick": "selected"}, ("2",), kept) == {**kept, "worker": "acme/Blog"}
+    assert form_choices({**rows, "pick": "suggested"}, ("1",), kept) == {
+        **kept,
+        "web": "acme/shop",
+        "worker": "acme/Blog",
+    }
+    # a no to the ticked ones, or to the row of Stop reading: the project is of no matter
+    assert form_choices({**rows, "pick": "skip"}, ("1",), kept) == {**kept, "web": ""}
+    assert form_choices({"name-1": "cache", "pick": "stop"}, (), kept) == {"cache": "", "old": "acme/gone"}
+    assert kept == {"cache": "acme/shop", "old": "acme/gone"}  # what it was given is not changed
+    # the others: a project typed next to a container, in any case; an empty field changes nothing, so that saving
+    # never erases a choice that the page shows apart
+    typed = {"name-1": "web", "project-1": " ACME/BLOG ", "name-2": "cache", "project-2": "", "name-3": "old"}
+    assert form_choices({**typed, "pick": "others"}, (), kept) == {**kept, "web": "acme/Blog"}
+    assert form_choices(typed, (), kept) == {**kept, "web": "acme/Blog"}  # a button that says nothing: the same
+    assert form_choices({}, (), kept) == kept and form_choices({"pick": "others"}) == {}
+
+
+def refused(form: dict[str, str], ticked: tuple[str, ...] = ()) -> logs.Refused:
+    with pytest.raises(logs.Refused) as raised:
+        form_choices(form, ticked, {"cache": "acme/shop"})
+    return raised.value
+
+
+def test_a_form_of_the_settings_page_is_refused_whole_when_part_of_it_is_not_acceptable() -> None:
+    rows = {"name-1": "web", "project-1": "acme/shop", "name-2": "worker", "project-2": "acme/blog"}
+    assert refused({**rows, "name-3": "../etc", "pick": "suggested"}).reason == "form"  # not a container's name
+    assert refused({**rows, "project-2": "acme/other", "pick": "suggested"}).reason == "form"  # forged: not a project
+    assert refused({**rows, "pick": "selected"}).reason == "none"  # nothing ticked
+    assert refused({**rows, "pick": "selected"}, ("7",)).reason == "none"  # a row that the form does not have
+    assert refused({"pick": "stop"}).reason == "none" and refused({"pick": "suggested"}).reason == "none"
+    wrong = refused({"name-1": "web", "project-1": "acme/shp", "name-2": "worker", "project-2": "ACME/shop"})
+    assert (wrong.reason, wrong.wrong) == ("project", "acme/shp")
+    assert wrong.typed == {"web": "acme/shp", "worker": "ACME/shop"}  # what was typed, to give back to the owner
diff --git a/tests/test_recipes.py b/tests/test_recipes.py
index 39c8fa2..3429748 100644
--- a/tests/test_recipes.py
+++ b/tests/test_recipes.py
@@ -58,7 +58,7 @@ def test_schemas_are_strict(name: str) -> None:
 
 
 def test_default_tiers() -> None:
-    assert defaults("claude-code")["deep"] == ("opus", "high")
+    assert defaults("claude-code")["deep"] == ("opus", "xhigh")
     assert set(defaults("codex")) == {"fast", "balanced", "deep"}
     with pytest.raises(ValueError, match="no default tiers"):
         defaults("scripted")
diff --git a/tests/test_tiers.py b/tests/test_tiers.py
new file mode 100644
index 0000000..c54be30
--- /dev/null
+++ b/tests/test_tiers.py
@@ -0,0 +1,99 @@
+"""The data file of tiers: the default model and effort of each tier, the model names that each CLI takes, and the
+effort levels that it takes."""
+
+import json
+from importlib import resources
+
+import pytest
+
+from lastcall.accounts import MODEL, Account
+from lastcall.tiers import SECTIONS, TIERS, defaults, efforts, models
+
+ENGINES = ("claude-code", "codex")  # the engines on a CLI login: the ones with default tiers
+
+
+def test_the_default_effort_follows_the_work() -> None:
+    for engine in ENGINES:
+        assert {tier: effort for tier, (_, effort) in defaults(engine).items()} == {
+            "fast": "medium",  # only a repository's own reviewers ask for it
+            "balanced": "high",  # the reviewers
+            "deep": "xhigh",  # the judge, the implementers and the improvement plans
+        }
+
+
+def test_the_default_models_are_the_ones_of_each_engine() -> None:
+    assert {tier: model for tier, (model, _) in defaults("claude-code").items()} == {
+        "fast": "haiku",
+        "balanced": "sonnet",
+        "deep": "opus",
+    }
+    assert {tier: model for tier, (model, _) in defaults("codex").items()} == {
+        "fast": "gpt-6-luna",
+        "balanced": "gpt-6.1-sol",
+        "deep": "gpt-6.1-sol",
+    }
+
+
+def test_every_default_effort_is_one_that_the_cli_takes() -> None:
+    for engine in ENGINES:
+        for tier, (_, effort) in defaults(engine).items():
+            assert effort in efforts(engine), (engine, tier)
+    assert "xhigh" in efforts("claude-code") and "xhigh" in efforts("codex")
+
+
+def test_the_efforts_of_an_engine_go_from_the_lowest_up() -> None:
+    for engine in ("claude-code", "codex", "opencode"):
+        levels = efforts(engine)
+        assert levels == tuple(sorted(levels, key=("minimal", "low", "medium", "high", "xhigh", "max").index)), engine
+
+
+def test_the_cli_of_an_account_gets_the_default_effort_of_each_of_its_tiers() -> None:
+    assert Account("max", "claude-code").tiers() == {
+        "fast": ("haiku", "medium"),
+        "balanced": ("sonnet", "high"),
+        "deep": ("opus", "xhigh"),
+    }
+    assert Account("chatgpt", "codex").tiers() == {
+        "fast": ("gpt-6-luna", "medium"),
+        "balanced": ("gpt-6.1-sol", "high"),
+        "deep": ("gpt-6.1-sol", "xhigh"),
+    }
+    own = Account("chatgpt", "codex", models={"deep": "gpt-6-astra"}, efforts={"fast": "low"}).tiers()
+    assert own["deep"] == ("gpt-6-astra", "xhigh") and own["fast"] == (
+        "gpt-6-luna",
+        "low",
+    )  # a model keeps its tier's
+
+
+def test_models_lists_what_each_cli_takes() -> None:
+    assert models("claude-code") == ("haiku", "sonnet", "opus")
+    assert models("codex") == ("gpt-6.1-sol", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna")
+
+
+def test_every_default_model_is_one_that_it_suggests() -> None:
+    for engine in ENGINES:
+        for tier, (model, _) in defaults(engine).items():
+            assert model in models(engine), (engine, tier)
+
+
+def test_every_suggestion_is_a_name_that_an_account_takes_and_none_is_there_twice() -> None:
+    for engine in ENGINES:
+        assert all(MODEL.fullmatch(name) for name in models(engine)), engine
+        assert len(set(models(engine))) == len(models(engine)), engine
+
+
+def test_an_engine_with_no_list_suggests_nothing() -> None:
+    # an API key's models come from models.dev, a local server's are the owner's, and a stand-in has none
+    for engine in ("opencode", "scripted", "nothing", "_about", "models", "efforts"):
+        assert models(engine) == (), engine
+
+
+def test_the_sections_of_the_file_are_not_engines() -> None:
+    for section in SECTIONS:
+        with pytest.raises(ValueError, match="no default tiers"):
+            defaults(section)
+    data = json.loads(resources.files("lastcall.data").joinpath("tiers.json").read_text(encoding="utf-8"))
+    for engine in set(data) - set(SECTIONS):
+        assert set(data[engine]) == set(TIERS), engine  # what is left is an engine, with its three tiers
+    assert set(data["models"]) - {"_about"} <= set(data) - set(SECTIONS)  # a list only for an engine that has tiers
+    assert all(data[section]["_about"] for section in ("models", "efforts"))  # each section says what it is
diff --git a/tests/test_web.py b/tests/test_web.py
index 88cde8c..b4cc3a6 100644
--- a/tests/test_web.py
+++ b/tests/test_web.py
@@ -3,7 +3,7 @@
 import json
 import re
 import threading
-from collections.abc import Callable, Collection, Mapping
+from collections.abc import Callable, Collection, Iterable, Mapping
 from dataclasses import replace
 from pathlib import Path
 from typing import Any, cast
@@ -18,6 +18,7 @@
 from werkzeug.test import TestResponse
 
 import lastcall.web as site
+from lastcall import catalog
 from lastcall.accounts import Account
 from lastcall.github import App, GitHub, Response
 from lastcall.notify import Notifier
@@ -40,6 +41,7 @@
     hash_password,
     start_session,
 )
+from test_catalog import CATALOG, ModelsDev, model
 from test_loki import FakeLoki
 from test_notify import Outbox
 from test_projects import APP, FakeGitHub
@@ -59,6 +61,12 @@ def __call__(self) -> float:
         return self.now
 
 
+def offline(req: Request) -> Response:
+    """The `fetch` of a test that gives none: nothing reaches the network (models.dev is never asked from a test), and
+    a lookup that needs it fails as it does on a host with no way out."""
+    raise OSError(f"offline: {req.full_url}")
+
+
 class Web:
     def __init__(
         self, tmp_path: Path, origins: tuple[str, ...] = (), github: FakeGitHub | None = None, **options: Any
@@ -79,6 +87,7 @@ def __init__(
             github=(lambda: cast(GitHub, github)) if github else None,
             background=options.pop("background", lambda work: work()),
             notifier=Notifier(self.secrets, self.store, send=self.outbox, log=self.logs.append),
+            fetch=options.pop("fetch", offline),
             **options,
         )
         self.client = self.app.test_client()
@@ -743,7 +752,7 @@ def test_models_and_effort_from_the_web(web: Web) -> None:
     assert row is not None and row.account().tiers() == {
         "fast": ("haiku", "medium"),
         "balanced": ("claude-sonnet-5-5", "high"),
-        "deep": ("opus", "high"),
+        "deep": ("opus", "xhigh"),
     }
     for bad in ({"effort-deep": "ultra"}, {"model-deep": "opus; rm -rf /"}):
         assert web.client.post("/accounts/max/tiers", data={**form, **bad}, headers=SITE).status_code == 400
@@ -964,26 +973,28 @@ def test_container_logs_from_the_web(tmp_path: Path) -> None:
     web.store.add_project("acme/blog")
     csrf = web.csrf()
     page = web.client.get("/settings").get_data(as_text=True)
-    assert "Container logs" in page and "Suggested: acme/shop. Save to read it." in page
-    assert '<option value="acme/shop" selected>acme/shop</option>' in page  # the suggestion comes chosen
-    assert "Read for acme/blog, from its label." in page and "lastcall.project: owner/name" in page
-    assert '<input type="hidden" name="shown-1" value="acme/shop">' in page
-    # each source's select says which container it is for, not only "Project"
+    # three parts (tests/test_lists.py has the rest): the label reads blog, the suggestion waits to be ticked, and
+    # redis is among the others. Changed with the new layout: a suggestion no longer comes chosen in a select
+    assert "Container logs" in page and "for acme/shop" in page and "lastcall.project: owner/name" in page
+    assert '<span class="mono">acme/blog</span> <span class="muted">· its label decides</span>' in page
+    assert '<input type="hidden" name="project-1" value="acme/shop">' in page  # what ticking it reads it for
+    assert '<input id="logs-pick-1" type="checkbox" name="tick" value="1" aria-describedby="logs-for-1">' in page
+    # each field says which container it is for, not only "Project"
     assert (
-        '<strong id="logs-name-1">shop-web-1</strong>' in page
-        and 'id="logs-1" aria-describedby="logs-name-1"' in page
+        'aria-label="Project for redis"' in page
+        and "<select" not in page.split('id="logs">')[1].split("</section>")[0]
     )
-    form = {"csrf": csrf, "name-1": "shop-web-1", "project-1": "acme/shop", "shown-1": "acme/shop"}
-    form |= {"name-3": "redis", "project-3": "", "shown-3": ""}
+    form = {"csrf": csrf, "name-1": "shop-web-1", "project-1": "acme/shop", "tick": "1", "pick": "selected"}
     response = web.client.post("/settings/logs", data=form, headers=SITE)
     assert response.headers["Location"] == "/settings?done=logs#logs"
-    assert logs.chosen(web.store) == {"shop-web-1": "acme/shop"}  # redis: no project, and none was shown
-    bad = {**form, "project-3": "someone/else"}
+    assert logs.chosen(web.store) == {"shop-web-1": "acme/shop"}  # redis: no project, and none was typed
+    bad = {"csrf": csrf, "name-1": "redis", "project-1": "someone/else", "pick": "others"}
     assert web.client.post("/settings/logs", data=bad, headers=SITE).status_code == 400
-    web.client.post("/settings/logs", data={**form, "project-1": ""}, headers=SITE)  # the owner says no to it
+    stop = {"csrf": csrf, "name-1": "shop-web-1", "pick": "stop"}
+    web.client.post("/settings/logs", data=stop, headers=SITE)  # the owner says no to it
     assert logs.chosen(web.store) == {"shop-web-1": ""}
     page = web.client.get("/settings").get_data(as_text=True)
-    assert "Suggested:" not in page and '<option value="acme/shop" selected>' not in page  # not suggested again
+    assert "for acme/shop" not in page and "chosen here" not in page  # not suggested again
 
     def broken() -> list[dict[str, Any]]:
         raise SandboxError("supervisor unreachable")
@@ -1037,10 +1048,12 @@ def fetch(url: str, headers: Mapping[str, str]) -> Any:
     page = web.client.get("/settings").get_data(as_text=True)
     assert "Connected to http://loki.example.com:3100." in page
     assert '<option value="container" selected>container</option>' in page
-    assert "Compose project: shop" in page and "Suggested: acme/shop. Save to read it." in page
-    assert 'id="loki-1" aria-describedby="loki-name-1"' in page and 'id="loki-name-1"' in page
-    rows = {"csrf": csrf, "label": "container", "name-1": "redis", "project-1": "", "shown-1": ""}
-    rows |= {"name-2": "shop-web-1", "project-2": "acme/shop", "shown-2": "acme/shop"}
+    # changed with the new layout: the suggestion is a tile to tick, and redis is among the others
+    assert "Compose project: shop" in page and "for acme/shop" in page
+    assert '<input id="loki-pick-1" type="checkbox" name="tick" value="1" aria-describedby="loki-for-1">' in page
+    assert 'aria-label="Project for redis"' in page
+    rows = {"csrf": csrf, "label": "container", "name-1": "shop-web-1", "project-1": "acme/shop"}
+    rows |= {"tick": "1", "pick": "selected"}
     response = web.client.post("/settings/loki/sources", data=rows, headers=SITE)
     assert response.headers["Location"] == "/settings?done=loki_sources#loki"
     assert (web.store.setting(loki.LABEL), loki.chosen(web.store)) == ("container", {"shop-web-1": "acme/shop"})
@@ -3041,12 +3054,12 @@ def test_a_removed_project_keeps_its_container_and_source_choices_and_settings_n
     page = web.client.get("/settings").get_data(as_text=True)
     note = "It was chosen for acme/shop, which is not a project now: add acme/shop again and it is read again."
     assert page.count(note) == 2  # a container and a source
-    assert '<option value="acme/blog" selected>' not in page and 'value="acme/shop"' not in page
-    assert page.count('<input type="hidden" name="shown-1" value="">') == 2  # the page shows no project for them
+    assert 'value="acme/shop"' not in page and "chosen here" not in page
+    assert page.count("Nothing is read yet.") == 2  # neither is read now: the project is not there to read them for
     spanish = web.client.get("/settings", headers={"Accept-Language": "es"}).get_data(as_text=True)
     assert spanish.count("Se eligió para acme/shop, que ya no es un proyecto: añade acme/shop de nuevo") == 2
     # saving the form as the page sends it keeps the choices
-    form = {"csrf": csrf, "name-1": "shop-web-1", "project-1": "", "shown-1": ""}
+    form = {"csrf": csrf, "name-1": "shop-web-1", "project-1": "", "pick": "others"}
     assert web.client.post("/settings/logs", data=form, headers=SITE).status_code == 302
     sources = web.client.post("/settings/loki/sources", data={**form, "label": "container"}, headers=SITE)
     assert sources.status_code == 302
@@ -3054,9 +3067,8 @@ def test_a_removed_project_keeps_its_container_and_source_choices_and_settings_n
     # adding the project again brings the choices back, with nothing to say about them
     web.store.add_project("acme/shop")
     page = web.client.get("/settings").get_data(as_text=True)
-    assert page.count('<option value="acme/shop" selected>acme/shop</option>') == 2
-    assert "is not a project now" not in page
-    assert page.count('<input type="hidden" name="shown-1" value="acme/shop">') == 2
+    assert page.count('<span class="mono">acme/shop</span> <span class="muted">· chosen here</span>') == 2
+    assert "is not a project now" not in page and page.count('aria-label="Stop reading shop-web-1"') == 2
     assert logs.names_for("acme/shop", listed, logs.chosen(web.store)) == ["shop-web-1"]
 
 
@@ -3067,3 +3079,420 @@ def test_without_popover_support_neither_the_question_nor_the_trash_button_shows
     assert ".trash, .bubble.confirm { display: none; }" in mine  # never a Remove button one click away in a card
     # an author's display on a popover overrides the browser's, and would show the closed question
     assert not re.search(r"\.bubble\.confirm\s*\{[^}]*\bdisplay:", css.replace(mine, ""))
+
+
+# the model fields suggest names: the CLI's own, or models.dev's for an API key (test_catalog's fakes never ask it)
+
+
+def account_html(page: str, account: str) -> str:
+    return page.split(f'id="account-{account}"')[1].split("</article>")[0]
+
+
+def datalists(page: str) -> dict[str, list[str]]:
+    """The datalists of a page, each with the values of its options."""
+    return {
+        found.group(1): [html.unescape(v) for v in re.findall(r'<option value="([^"]*)"></option>', found.group(2))]
+        for found in re.finditer(r'<datalist id="([^"]+)">(.*?)</datalist>', page, re.S)
+    }
+
+
+def lists_of(section: str, fields: Iterable[str]) -> list[str | None]:
+    """The datalist that each of these inputs points to with `list`: None for an input with none."""
+    found: list[str | None] = []
+    for name in fields:
+        tag = re.search(rf'<input [^>]*name="{name}"[^>]*>', section)
+        assert tag, name
+        attribute = re.search(r' list="([^"]+)"', tag.group(0))
+        found.append(attribute.group(1) if attribute else None)
+    return found
+
+
+def models_web(tmp_path: Path, fetch: ModelsDev | None = None, accounts: bool = True) -> tuple[Web, ModelsDev]:
+    """A signed-in web UI whose `fetch` is models.dev's fake, with one account of each kind."""
+    from lastcall.accounts import tier_models
+
+    fetch = fetch or ModelsDev()
+    web = Web(tmp_path, fetch=fetch)
+    web.set_up()
+    if not accounts:
+        return web, fetch
+    web.store.add_account("max", "claude-code")
+    web.store.add_account("chatgpt", "codex")
+    for name, provider in (("router", "openrouter"), ("direct", "anthropic"), ("sky", "openai")):
+        web.store.add_account(
+            name, "opencode", provider=provider, models=tier_models("a-model"), policy="budget", budget_usd=20
+        )
+    web.store.add_account("local", "opencode", provider="ollama", models=tier_models("qwen3-coder"), policy="manual")
+    return web, fetch
+
+
+# what test_catalog's catalog lists that a step can run on, in the order of the datalists
+OPENROUTER = ["anthropic/claude-sonnet-5.5", "beta/new-model", "qwen/qwen3-coder"]
+OPENROUTER += ["Qwen/Qwen3-coder-flash", "qwen/qwen3-coder:free"]
+EVERY_PROVIDER = sorted(
+    [*OPENROUTER, "claude-opus-5-5", "claude-sonnet-5-5", "gpt-6.1-sol"], key=lambda n: (n.lower(), n)
+)
+
+
+def test_the_model_field_of_each_tier_suggests_the_models_of_its_own_engine(tmp_path: Path) -> None:
+    web, fetch = models_web(tmp_path)
+    page = web.client.get("/accounts").get_data(as_text=True)
+    found = datalists(page)
+    assert found["models-claude-code"] == ["haiku", "sonnet", "opus"]  # lastcall's own list, from data/tiers.json
+    assert found["models-codex"] == ["gpt-6.1-sol", "gpt-6-astra", "gpt-6-sol", "gpt-6-luna"]
+    assert found["models-opencode-openrouter"] == OPENROUTER  # what models.dev lists, as test_catalog filters it
+    assert found["models-opencode-anthropic"] == ["claude-opus-5-5", "claude-sonnet-5-5"]
+    assert found["models-opencode-openai"] == ["gpt-6.1-sol"]
+    assert found["models-keys"] == EVERY_PROVIDER
+    assert len(found) == 6  # none for the local model server: the web UI cannot reach it
+    fields = [f"model-{tier}" for tier in TIERS]
+    for account, wanted in (
+        ("max", "models-claude-code"),
+        ("chatgpt", "models-codex"),
+        ("router", "models-opencode-openrouter"),
+        ("direct", "models-opencode-anthropic"),
+        ("sky", "models-opencode-openai"),
+    ):
+        assert lists_of(account_html(page, account), fields) == [wanted] * 3, account
+    assert lists_of(account_html(page, "local"), fields) == [None] * 3
+    assert all(page.count(f'<datalist id="{name}">') == 1 for name in found)  # once each, whatever points to it
+    assert len(fetch.asked) == 1  # one request, for every provider
+
+
+def test_two_accounts_of_a_kind_share_the_one_datalist_of_their_provider(tmp_path: Path) -> None:
+    from lastcall.accounts import tier_models
+
+    web, _ = models_web(tmp_path)
+    web.store.add_account(
+        "router-2", "opencode", provider="openrouter", models=tier_models("a-model"), policy="budget", budget_usd=5
+    )
+    web.store.add_account("max-2", "claude-code")
+    page = web.client.get("/accounts").get_data(as_text=True)
+    assert page.count('<datalist id="models-opencode-openrouter">') == 1
+    assert page.count('<datalist id="models-claude-code">') == 1
+    assert page.count('list="models-opencode-openrouter"') == 6 and page.count('list="models-claude-code"') == 6
+
+
+def test_the_fold_says_where_its_suggestions_come_from(tmp_path: Path) -> None:
+    web, _ = models_web(tmp_path)
+    page = web.client.get("/accounts").get_data(as_text=True)
+    said = {
+        "max": "The Model field suggests the names that Claude Code takes. Pick one, or type any other.",
+        "chatgpt": "The Model field suggests the names that Codex takes. Pick one, or type any other.",
+        "router": "The Model field suggests what models.dev lists for OpenRouter: models that use tools and have a "
+        "price. Pick one, or type any other.",
+        "direct": "The Model field suggests what models.dev lists for Anthropic API: models that use tools and "
+        "have a price. Pick one, or type any other.",
+    }
+    for account, text in said.items():
+        assert f'<p class="hint">{text}</p>' in account_html(page, account), account
+    assert "The Model field suggests" not in account_html(page, "local")
+    spanish = web.client.get("/accounts", headers={"Accept-Language": "es"}).get_data(as_text=True)
+    assert (
+        "El campo Modelo sugiere los nombres que acepta Claude Code. Elige uno o escribe cualquier otro." in spanish
+    )
+    assert (
+        "El campo Modelo sugiere lo que models.dev lista para OpenRouter: modelos que usan herramientas y tienen "
+        in (account_html(spanish, "router"))
+    )
+
+
+def test_the_form_that_adds_an_api_key_suggests_the_models_of_every_provider(tmp_path: Path) -> None:
+    web, _ = models_web(tmp_path, accounts=False)  # the form is there with no card above it
+    english = web.client.get("/accounts").get_data(as_text=True)
+    spanish = web.client.get("/accounts", headers={"Accept-Language": "es"}).get_data(as_text=True)
+    assert datalists(english) == {"models-keys": EVERY_PROVIDER}
+    for page in (english, spanish):
+        form = page.split('<div class="dest dest-key">')[1].split('<div class="dest ')[0]
+        assert lists_of(form, ["model", "review_model"]) == ["models-keys", "models-keys"]
+        local = page.split('<div class="dest dest-local">')[1]
+        assert lists_of(local, ["model"]) == [None]  # a local model server has no list to suggest from
+    hint = english.split('id="key-model-hint"')[1].split("</p>")[0]
+    assert (
+        "The field suggests what models.dev lists for all the providers, and OpenRouter writes the maker first"
+        in hint
+    )
+    assert "Pick one from the provider you chose, or type any other." in hint
+    assert "El campo sugiere lo que models.dev lista para todos los proveedores" in spanish
+
+
+def test_without_models_dev_the_form_that_adds_a_key_is_as_it_was(web: Web) -> None:
+    web.set_up()  # the web fixture's fetch is the offline one of the tests
+    page = web.client.get("/accounts").get_data(as_text=True)
+    assert "<datalist" not in page and ' list="' not in page
+    form = page.split('<div class="dest dest-key">')[1].split('<div class="dest ')[0]
+    assert "The model of every step, as the provider's list names it. lastcall counts" in html.unescape(form)
+    assert "models.dev lists" not in form
+
+
+def test_the_efforts_of_the_tiers_say_their_defaults(tmp_path: Path) -> None:
+    web, _ = models_web(tmp_path)
+    page = web.client.get("/accounts").get_data(as_text=True)
+    for account in ("max", "chatgpt"):  # the same for both: medium for fast, high for balanced, xhigh for deep
+        found = re.findall(r'<option value="">Default \((\w+)\)</option>', account_html(page, account))
+        assert found == ["medium", "high", "xhigh"], account
+    spanish = web.client.get("/accounts", headers={"Accept-Language": "es"}).get_data(as_text=True)
+    found = re.findall(r'<option value="">Por defecto \((\w+)\)</option>', account_html(spanish, "chatgpt"))
+    assert found == ["medium", "high", "xhigh"]
+
+
+def test_models_dev_is_asked_once_a_day_for_every_provider_with_a_wait_of_5_seconds(tmp_path: Path) -> None:
+    web, fetch = models_web(tmp_path)
+    for _ in range(3):
+        assert web.client.get("/accounts").status_code == 200
+    assert len(fetch.asked) == 1  # three loads, one request
+    (req,) = fetch.asked
+    assert site.CATALOG_TIMEOUT == 5 and getattr(req, "timeout", None) == 5
+    assert (req.get_header("User-agent") or "").startswith("lastcall/") and req.get_header(
+        "Accept-encoding"
+    ) == "gzip"
+    web.clock.now += DAY - 1
+    web.client.get("/accounts")
+    assert len(fetch.asked) == 1
+    web.clock.now += 2
+    fetch.answer = {"openrouter": {"models": {"new/model": model()}}}  # models.dev changed its mind
+    page = web.client.get("/accounts").get_data(as_text=True)
+    assert len(fetch.asked) == 2
+    found = datalists(page)
+    assert found["models-opencode-openrouter"] == ["new/model"] and found["models-keys"] == ["new/model"]
+    assert "models-opencode-anthropic" not in found  # it lists none now, and is not asked again before the day is out
+    web.clock.now += DAY - 1
+    web.client.get("/accounts")
+    assert len(fetch.asked) == 2
+
+
+def test_only_the_accounts_page_asks_models_dev(tmp_path: Path) -> None:
+    web, fetch = models_web(tmp_path)
+    for path in ("/", "/projects", "/settings", "/github", "/login", "/healthz"):
+        web.client.get(path)
+    assert fetch.asked == []
+    web.client.get("/accounts")
+    assert len(fetch.asked) == 1
+
+
+FAILURES: list[Exception | tuple[int, bytes]] = [
+    OSError("no route to host"),
+    TimeoutError("timed out"),
+    RuntimeError("boom"),
+    (403, b"<html>Forbidden</html>"),
+    (500, b""),
+    (200, b"<html>a captive portal</html>"),
+    (200, b"[]"),
+    (200, b"null"),
+]
+
+
+@pytest.mark.parametrize("answer", FAILURES)
+def test_when_models_dev_does_not_answer_the_fields_suggest_nothing_and_the_page_goes_on(
+    tmp_path: Path, answer: Exception | tuple[int, bytes]
+) -> None:
+    web, _ = models_web(tmp_path, ModelsDev(answer))
+    response = web.client.get("/accounts")
+    page = response.get_data(as_text=True)
+    assert response.status_code == 200
+    assert sorted(datalists(page)) == ["models-claude-code", "models-codex"]  # what lastcall knows itself stays
+    assert lists_of(account_html(page, "router"), ["model-fast", "model-deep"]) == [None, None]
+    form = page.split('<div class="dest dest-key">')[1].split('<div class="dest ')[0]
+    assert lists_of(form, ["model", "review_model"]) == [None, None] and "models.dev lists" not in form
+    assert "models.dev lists for OpenRouter" not in account_html(page, "router")
+    assert 'name="model-deep"' in account_html(page, "router") and 'value="a-model"' in account_html(page, "router")
+    said = [line for line in web.logs if "models.dev gave no models" in line]
+    assert len(said) == 1 and "\n" not in said[0]  # one line in the log, never the answer
+
+
+def test_a_models_dev_that_does_not_answer_is_asked_again_after_10_minutes_not_at_every_load(tmp_path: Path) -> None:
+    web, fetch = models_web(tmp_path, ModelsDev(OSError("no route to host")))
+    for _ in range(3):
+        assert web.client.get("/accounts").status_code == 200
+    assert len(fetch.asked) == 1  # three loads, one wait
+    web.clock.now += 599
+    web.client.get("/accounts")
+    assert len(fetch.asked) == 1
+    web.clock.now += 2
+    fetch.answer = CATALOG
+    page = web.client.get("/accounts").get_data(as_text=True)
+    assert len(fetch.asked) == 2 and datalists(page)["models-opencode-openrouter"] == OPENROUTER
+    web.clock.now += 3600  # an answer is kept the whole day
+    web.client.get("/accounts")
+    assert len(fetch.asked) == 2
+
+
+def test_what_models_dev_says_is_bounded(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(catalog, "MAX_MODELS", 3)
+    many = {
+        name: {"models": {f"{name}/m{n:02}": model() for n in range(10, 0, -1)}}
+        for name in ("openrouter", "anthropic", "openai", "ollama-cloud", "mistral", "groq")
+    }
+    web, fetch = models_web(tmp_path, ModelsDev(many))
+    found = datalists(web.client.get("/accounts").get_data(as_text=True))
+    assert found["models-opencode-openrouter"] == ["openrouter/m01", "openrouter/m02", "openrouter/m03"]  # 3 at most
+    assert len(found["models-keys"]) == 9  # of the three providers that an engine offers: not of the other three
+    assert not any("mistral" in name or "groq" in name for name in found["models-keys"])
+    assert len(fetch.asked) == 1
+
+
+def test_a_catalog_over_the_limit_is_refused_and_the_page_goes_on(
+    tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    monkeypatch.setattr(catalog, "MAX_BYTES", 500)
+    web, _ = models_web(tmp_path)
+    response = web.client.get("/accounts")
+    found = datalists(response.get_data(as_text=True))
+    assert response.status_code == 200 and "models-opencode-openrouter" not in found
+    assert any("too big" in line for line in web.logs)
+
+
+# the settings of a project say plainly what each option adds, and an account says what its language is for
+
+HINTS = {
+    "en": {
+        "tests": "Some bursts write tests instead of auditing: pull requests that add tests for behavior no test "
+        "checks.",
+        "deps": "Some bursts upgrade dependencies instead of auditing: pull requests for what needs more than a new "
+        "version number.",
+        "merge": "When you approve one of its pull requests on GitHub, lastcall merges it once its checks pass. "
+        "Without this, you merge it yourself.",
+        "watch": "For a day after a merge, lastcall watches only the merged commit's checks and the health address "
+        "below, not your logs or error tracker. If either breaks, it proposes a revert and pauses the project.",
+    },
+    "es": {
+        "tests": "Algunas ráfagas escriben tests en lugar de auditar: pull requests que añaden tests para el "
+        "comportamiento que ningún test comprueba.",
+        "deps": "Algunas ráfagas actualizan dependencias en lugar de auditar: pull requests para lo que necesita "
+        "algo más que un número de versión nuevo.",
+        "merge": "Cuando apruebas uno de sus pull requests en GitHub, lastcall lo fusiona en cuanto pasan sus "
+        "checks. Sin esto, lo fusionas tú.",
+        "watch": "Durante un día tras una fusión, lastcall vigila solo los checks del commit fusionado y la "
+        "dirección de salud de abajo, no tus logs ni tu tracker de errores. Si alguno falla, propone una reversión "
+        "y pausa el proyecto.",
+    },
+}
+
+
+def bubble(page: str, name: str) -> str:
+    """The text of a help bubble, as a reader sees it."""
+    found = re.search(rf'<div id="help-{name}" popover.*?</div>', page, re.S)
+    assert found, name
+    return html.unescape(re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", found.group(0)))).strip()
+
+
+@pytest.mark.parametrize("lang", ["en", "es"])
+def test_each_project_option_says_plainly_what_it_adds(github_web: Web, lang: str) -> None:
+    web = github_web
+    web.store.add_project("acme/api")
+    page = web.client.get("/projects", headers={"Accept-Language": lang}).get_data(as_text=True)
+    found = re.findall(
+        r'<p class="hint" id="(tests|deps|merge|watch)-hint-1">(.*?)</p>', card(page, "acme/api"), re.S
+    )
+    assert {name: html.unescape(text) for name, text in found} == HINTS[lang]
+
+
+@pytest.mark.parametrize(
+    ("lang", "label", "option", "hint"),
+    [
+        (
+            "en",
+            "Language of its pull requests and issues",
+            "Same as the account",
+            "“Same as the account” uses the language of whichever account works on it, set on the Accounts page.",
+        ),
+        (
+            "es",
+            "Idioma de sus pull requests e issues",
+            "Igual que la cuenta",
+            "«Igual que la cuenta» usa el idioma de la cuenta que trabaje en él, el que se elige en Cuentas.",
+        ),
+    ],
+)
+def test_a_projects_language_says_what_it_is_and_what_its_default_means(
+    github_web: Web, lang: str, label: str, option: str, hint: str
+) -> None:
+    web = github_web
+    web.store.add_project("acme/api")
+    page = web.client.get("/projects", headers={"Accept-Language": lang}).get_data(as_text=True)
+    mine = card(page, "acme/api")
+    assert f'<label for="language-1">{label}</label><button type="button" class="help"' in mine
+    assert f'<option value="" selected>{option}</option>' in mine
+    assert '<select id="language-1" name="language" aria-describedby="language-hint-1">' in mine
+    assert f'<p class="hint" id="language-hint-1">{hint}</p>' in mine  # what the default means, under the select
+    quoted = f"“{option}”" if lang == "en" else f"«{option}»"
+    assert quoted in bubble(page, "projects-language")  # the bubble calls the option as the select does
+
+
+@pytest.mark.parametrize(
+    ("lang", "label"),
+    [
+        ("en", "Language of its pull requests and issues"),
+        ("es", "Idioma de sus pull requests e issues"),
+    ],
+)
+def test_an_accounts_language_says_what_it_is_in_its_card_and_in_every_form_that_adds_one(
+    tmp_path: Path, lang: str, label: str
+) -> None:
+    web, _ = models_web(tmp_path)
+    page = web.client.get("/accounts", headers={"Accept-Language": lang}).get_data(as_text=True)
+    mine = account_html(page, "max")  # the number in the id is the card's place in the page
+    assert re.search(rf'<label for="language-\d+">{label}</label><button type="button" class="help"', mine)
+    for field in ("language", "key-language", "local-language"):
+        assert f'<label for="{field}">{label}</label><button type="button" class="help"' in page, field
+    assert bubble(page, "accounts-language").startswith(f"{label} ")  # the bubble is titled with it
+
+
+def test_the_two_selects_of_a_projects_settings_get_a_row_each_and_the_page_has_no_style_of_its_own(
+    github_web: Web,
+) -> None:
+    """A closed select cuts its text short (the language says "Same as the account" in a space of 27 characters on a
+    phone), and half a card is less: each select has the whole row."""
+    css = (Path(__file__).parent.parent / "src/lastcall/web/static/style.css").read_text(encoding="utf-8")
+    assert ".project-settings .fields { grid-template-columns: minmax(0, 1fr); }" in css
+    github_web.store.add_project("acme/api")
+    page = github_web.client.get("/projects").get_data(as_text=True)
+    assert " style=" not in page and "<style" not in page and "<script" not in page
+    assert not re.search(r"\son[a-z]+=", page)
+
+
+def test_the_details_line_of_an_account_still_says_what_language_it_writes_in(web: Web) -> None:
+    web.set_up()
+    web.store.add_account("claude", "claude-code", "Spanish", 10)
+    assert "Writes in Spanish · reserve 10%" in web.client.get("/accounts").get_data(as_text=True)
+    page = web.client.get("/accounts", headers={"Accept-Language": "es"}).get_data(as_text=True)
+    assert "Escribe en español · reserva " in page
+
+
+@pytest.mark.parametrize("lang", ["en", "es"])
+def test_the_help_of_the_watch_says_that_logs_and_trackers_take_no_part_in_it(github_web: Web, lang: str) -> None:
+    web = github_web
+    web.store.add_project("acme/api")
+    page = web.client.get("/projects", headers={"Accept-Language": lang}).get_data(as_text=True)
+    text = bubble(page, "projects-watch")
+    if lang == "en":
+        assert (
+            "watches two things only: the checks of the merged commit and, if you give one, the health address"
+            in text
+        )
+        assert "Container logs, Loki and your error tracker take no part in the watch" in text
+        assert "they feed the audits, which use them to find the causes of errors" in text
+    else:
+        assert "vigila solo dos cosas: los checks del commit fusionado y, si das una, la dirección de salud" in text
+        assert "Los logs de contenedores, Loki y tu tracker de errores no intervienen en la vigilancia" in text
+        assert "alimentan las auditorías, que los usan para encontrar las causas de los errores" in text
+
+
+@pytest.mark.parametrize("lang", ["en", "es"])
+def test_the_help_of_merging_and_of_the_turns_says_what_each_adds(github_web: Web, lang: str) -> None:
+    web = github_web
+    web.store.add_project("acme/api")
+    page = web.client.get("/projects", headers={"Accept-Language": lang}).get_data(as_text=True)
+    merge, turns = bubble(page, "projects-merge_on_approve"), bubble(page, "projects-turns")
+    if lang == "en":
+        assert "every 10 minutes" in merge and "(never a revert)" in merge and "Without this, you merge them" in merge
+        assert "protected branch" in merge and "A tests run opens pull requests that only add tests" in turns
+        assert "Tick “Tests too”, “Dependencies too” or both" in turns and "ticked or not" in turns
+    else:
+        assert (
+            "cada 10 minutos" in merge and "(nunca una reversión)" in merge and "Sin esto, los fusionas tú" in merge
+        )
+        assert (
+            "rama protegida" in merge and "Una ejecución de tests abre pull requests que solo añaden tests" in turns
+        )
+        assert "Marca «También tests», «También dependencias» o las dos" in turns and "estén marcadas o no" in turns