From b490f7691f7c85cb0d5f8f85ce6e1fc94b32eb21 Mon Sep 17 00:00:00 2001
From: Tomas McMonigal <74835766+sudoTomas@users.noreply.github.com>
Date: Thu, 5 Nov 2026 21:41:52 +0000
Subject: [PATCH 1/4] feat(slop): the Slop-O-Meter's scoring as a settings
 section

The meter kept all of its policy in code: the file weights and which
directories are vendored or tests, the pace and cap constants, the
small-repository rule, the level bounds and names and the judge's
prompt. An organization could not say what counts as code, how fast
its team works or where its levels fall, and changing a constant
silently rescored every repository. Its reading pace was three
variables, and an owner's own bots sat on its organization row.

Add a `slop_meter` section to the settings document. Every constant is
a key whose default is the value the code held, so nothing written
scores bit for bit as before: a fixture history reproduces the pinned
pre-change numbers, and 86,000 paths weigh what the old rules gave
them. An organization's layer may set every key but `enabled` and
`interval_hours`; a repository's what counts as code in its layout.
`weights` maps a glob to a weight, merged glob by glob through every
layer, the longest glob winning.

Each score row records `config_version` (migration 144), a digest of
the keys its repository's score is computed from. The loop now looks
at the section every five minutes: a change that gives a repository it
read another version rescores at once, `enabled` and `interval_hours`
apply within the look, and turning the meter on reads at the next one.
The forge budget is read per organization; organizations sharing one
credential get the fewest calls and the largest reserve.

SLOP_METER_INTERVAL_SECONDS (0 is `enabled: false`),
SLOP_METER_API_CALLS_PER_TICK and SLOP_METER_RATE_RESERVE are imported
once and then ignored. The organization setting `slop_meter_bots` moves
into its layer as `bots`, copied at the first start and still taken by
PATCH /orgs until 0.2.0. The process limits stay variables. The
unread LEAN_LEVEL constant is deleted: triage's lean belongs to the
routing section a later pull request adds. Multi-line texts in the
settings YAML are now written as literal blocks, so the judge's prompt
reads as written.

Refs #169
---
 .env.example                                  |  24 +-
 docs/api.md                                   |   6 +-
 docs/architecture.md                          |   1 +
 docs/configuration.md                         |  45 +-
 docs/examples/settings.yaml                   | 288 +++++++++
 docs/glossary.md                              |   2 +-
 docs/slop-meter.md                            |  96 ++-
 embry0/api/app.py                             |  25 +-
 embry0/api/v1/slop_meter.py                   |   7 +-
 embry0/config.py                              |  24 +-
 embry0/mcp_server/server.py                   |   6 +-
 embry0/services/organizations.py              |  29 +-
 embry0/services/slop_meter/context.py         |   3 -
 embry0/services/slop_meter/globs.py           | 132 +++++
 embry0/services/slop_meter/history.py         |  25 +-
 embry0/services/slop_meter/judge.py           |  35 +-
 embry0/services/slop_meter/loop.py            | 353 ++++++++---
 embry0/services/slop_meter/score.py           | 123 ++--
 embry0/services/slop_meter/weights.py         | 151 +++--
 embry0/settings/document.py                   |  18 +-
 embry0/settings/sections/__init__.py          |   2 +
 embry0/settings/sections/slop_meter.py        | 556 ++++++++++++++++++
 embry0/storage/migrations/runner.py           |  13 +
 embry0/storage/repositories/slop_meter.py     |  16 +-
 frontend/src/api/slopMeter.ts                 |  11 +-
 tests/unit/api/test_background_scope_live.py  |  17 +-
 .../unit/api/test_slop_meter_settings_live.py | 270 +++++++++
 .../v1/test_organization_register_settings.py |  10 +-
 tests/unit/api/v1/test_slop_meter_api.py      |   8 +-
 tests/unit/services/slop_meter/test_loop.py   |  74 ++-
 .../services/slop_meter/test_loop_settings.py | 277 +++++++++
 .../slop_meter/test_mirror_subgroups.py       |   4 +-
 tests/unit/services/slop_meter/test_prune.py  |  28 +-
 .../slop_meter/test_scoring_settings.py       | 317 ++++++++++
 .../test_background_scope_transients.py       |   6 +-
 tests/unit/settings/test_budget_section.py    |   1 +
 tests/unit/settings/test_registry.py          |   6 +-
 .../unit/settings/test_slop_meter_section.py  | 310 ++++++++++
 tests/unit/storage/test_migration_143.py      |   6 +-
 tests/unit/storage/test_migration_144.py      |  71 +++
 40 files changed, 3040 insertions(+), 356 deletions(-)
 create mode 100644 embry0/services/slop_meter/globs.py
 create mode 100644 embry0/settings/sections/slop_meter.py
 create mode 100644 tests/unit/api/test_slop_meter_settings_live.py
 create mode 100644 tests/unit/services/slop_meter/test_loop_settings.py
 create mode 100644 tests/unit/services/slop_meter/test_scoring_settings.py
 create mode 100644 tests/unit/settings/test_slop_meter_section.py
 create mode 100644 tests/unit/storage/test_migration_144.py

diff --git a/.env.example b/.env.example
index f9181943..0afb37b9 100644
--- a/.env.example
+++ b/.env.example
@@ -182,17 +182,19 @@ PROXY_ADMIN_TOKEN=
 # settings document, per organization and repository (docs/configuration.md);
 # none until one is enrolled. A repository that leaves loses its mirror and
 # its rows background.prune_after_days later (docs/ops/background-data.md).
-# 0 turns the loop off. Each tick's
-# work per repository is bounded; a large history is read over ticks. Forge
-# API calls have one budget per credential per tick, dealt round-robin among
-# its repositories, and stop when that credential's rate limit drops below
-# the reserve (jobs use the same credential); git fetches are not API calls.
-# SLOP_METER_REPOS and SLOP_METER_EXCLUDE are read once, at the first start of
-# the release that added the background section, into the repositories'
-# layers, and ignored after that. Do not add them here.
-# SLOP_METER_API_CALLS_PER_TICK=200
-# SLOP_METER_RATE_RESERVE=2000
-# SLOP_METER_INTERVAL_SECONDS=86400
+# How it scores, how often it reads (and whether it reads at all) and its
+# forge budget per credential are the `slop_meter` section of the settings
+# document, not variables: edit it with PUT /api/v1/config/settings.
+# SLOP_METER_INTERVAL_SECONDS, SLOP_METER_API_CALLS_PER_TICK and
+# SLOP_METER_RATE_RESERVE are read once, at the first start of the release
+# that added the section, and ignored after that; the next release removes
+# them. SLOP_METER_REPOS and SLOP_METER_EXCLUDE are read once, at the first
+# start of the release that added the background section, into the
+# repositories' layers, and ignored after that. Do not add them here.
+# The variables below are the process's own limits: each tick's work per
+# repository is bounded, so a large history is read over ticks, coming back
+# after the catch-up interval while one is behind; git fetches are not API
+# calls, and every git call has a timeout.
 # SLOP_METER_CATCHUP_SECONDS=300
 # SLOP_METER_DATA_PATH=/data/embry0/slop-meter
 # SLOP_METER_GIT_TIMEOUT_SECONDS=900
diff --git a/docs/api.md b/docs/api.md
index 14163453..16f66f6a 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -90,7 +90,7 @@ curl http://localhost:8200/api/v1/jobs/{job_id}/agents/developer/session
 
 A job's `area` (on the list and on `GET /jobs/{job_id}`) is the part of a monorepo the pull request embry0 opened for it changes, from the repository's `.embry0/areas.yml` ([areas](areas.md)); `null` when the repository names none or the change falls in none. `GET /repos/{repo}/-/areas` reads that file, and `POST /repos/{repo}/-/areas/map` starts the agent that writes it as a pull request ([map areas](areas.md#map-areas)).
 
-`GET /repos/{repo}/-/slop-meter?area=` is the repository's [Slop-O-Meter](glossary.md#slop-o-meter) (after [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm): `meter` (the repository's `{score, level, name, provisional, computed_at}`, `null` before its first score), `areas` (each scored area's `{area, meter}`), `area` (the series' area, `null` for the repository), `weeks` (`{week, cost, capacity, slop, lines, score}` oldest first, in weighted lines; `score` cumulative) and `reading` (`{commits_read, commits_total, computed_at, error}`, how far the history is read). 404 for an unregistered repository or an area with no reading. A repository the meter does not read (`background.slop_meter`, [which repositories](configuration.md#which-repositories-background-features-read)) gets no new reading: what the meter kept of one that left is removed `background.prune_after_days` later, and `meter` is then `null`. An inactive one keeps its reading.
+`GET /repos/{repo}/-/slop-meter?area=` is the repository's [Slop-O-Meter](glossary.md#slop-o-meter) (after [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm): `meter` (the repository's `{score, level, name, provisional, computed_at}`, `null` before its first score), `areas` (each scored area's `{area, meter}`), `area` (the series' area, `null` for the repository), `weeks` (`{week, cost, capacity, slop, lines, score}` oldest first, in weighted lines; `score` cumulative) and `reading` (`{commits_read, commits_total, computed_at, error, config_version}`, how far the history is read, and the version of the `slop_meter` settings the repository's score was computed with, `null` for a score from before #169: [how a change rescores](slop-meter.md#how-a-change-rescores)). 404 for an unregistered repository or an area with no reading. A repository the meter does not read (`background.slop_meter`, [which repositories](configuration.md#which-repositories-background-features-read)) gets no new reading: what the meter kept of one that left is removed `background.prune_after_days` later, and `meter` is then `null`. An inactive one keeps its reading.
 
 `POST /jobs/{job_id}/resume` takes `{"choice": "continue_retrying"|"merge_as_is"|"abandon", "guidance", "extra_budget_usd"}`. On a job over its budget, `continue_retrying` lets it spend one more cap past what it has spent (`budget.continue_default_extra_usd` of the [settings document](configuration.md#settings-document) when set), or `extra_budget_usd` when given: at most `budget.continue_extra_max_usd`, 1,000 by default, read when the request comes in, and a 422 naming that key above it. A continue that names nothing is held to the same most. The pause's `interrupt.summary.budget` says `{spent, cap, continue_adds}` ([per-job cap](architecture.md#budget-controls)). A continue goes on top of the fleet ceiling, `budget.max_budget_per_job_usd`, unless `budget.continue_may_exceed_ceiling` is false: then it adds at most what is left under the ceiling, and a job at it is not offered `continue_retrying` (one answered anyway is abandoned). Each continue that raises a job's cap writes a `job.budget_raised` audit row naming who continued it, with `job_id`, `spent_usd`, `cap_before_usd`, `cap_after_usd` and the `extra_usd` asked for.
 
@@ -741,9 +741,9 @@ A repository whose `context_audit.days` is set (the [settings document](configur
 | `context_audit_budget_usd` | number more than 0 and at most 50, or `null` | `null` | Deprecated: the organization's layer of the settings document's `budget.context_audit_job_usd` now. Taken until 0.2.0, see below |
 | `context_audit_max_jobs_per_tick` | integer from 0 to 50, or `null` | `null` | Deprecated: the organization's layer of `budget.context_audit_max_jobs_per_tick` now. Taken until 0.2.0, see below |
 | `context_audit_open_prs` | boolean | off | Deprecated: the organization's layer of `context_audit.open_prs` now. Taken until 0.2.0, see below |
-| `slop_meter_bots` | list of up to 100 strings, each at most 200 characters | empty | The owner's own bots: commit names, addresses and forge logins the Slop-O-Meter counts as a bot's, not a person's attention. embry0's own commit identities are always counted so; the list applies to every reading, including history read before it was set |
+| `slop_meter_bots` | list of up to 100 strings, each at most 200 characters | empty | Deprecated: the organization's layer of the settings document's `slop_meter.bots` now. Taken until 0.2.0, see below |
 
-**Moved settings.** `context_audit_budget_usd` and `context_audit_max_jobs_per_tick` are the organization's layer of the settings document's `budget` section now, as `context_audit_job_usd` and `context_audit_max_jobs_per_tick` (`PATCH /api/v1/config/settings/budget?owner=acme`), where an organization may also set `area_map_job_usd` and `fix_job_usd`. `context_audit_days` and `context_audit_open_prs` are its layer of the `context_audit` section, as `days` and `open_prs` (`PATCH /api/v1/config/settings/context_audit?owner=acme`), where a repository's own layer may set them too and `days: false` turns the schedule off whatever the layer below says (#170). The first start of each release that moved them copied each organization's value into its layer once, when the old reader would have used it (a value it read as the deployment's is nothing to copy); the value left on the organization is read by nothing, and `GET /api/v1/orgs` no longer shows it. Until 0.2.0, `PATCH` and `POST /api/v1/orgs` still take them, checked as above, and write them into the organization's layer instead, with every rule of that route (a revision with source `person`, a `settings.updated` audit row, a key with no repository allowlist); `null` takes the key out of the layer, so the organization reads the deployment's value. The answer then carries `deprecated`: one `{"setting", "moved_to", "removed_in", "detail"}` per moved setting it took. 0.2.0 refuses them.
+**Moved settings.** `context_audit_budget_usd` and `context_audit_max_jobs_per_tick` are the organization's layer of the settings document's `budget` section now, as `context_audit_job_usd` and `context_audit_max_jobs_per_tick` (`PATCH /api/v1/config/settings/budget?owner=acme`), where an organization may also set `area_map_job_usd` and `fix_job_usd`. `context_audit_days` and `context_audit_open_prs` are its layer of the `context_audit` section, as `days` and `open_prs` (`PATCH /api/v1/config/settings/context_audit?owner=acme`), where a repository's own layer may set them too and `days: false` turns the schedule off whatever the layer below says (#170). `slop_meter_bots` is its layer of the `slop_meter` section, as `bots` (`PATCH /api/v1/config/settings/slop_meter?owner=acme`): the owner's own bots, which the Slop-O-Meter counts as a bot's work, not a person's attention, beside embry0's own commit identities, applied to every reading, history read before they were listed included (#169). Each organization's list was copied with its blanks left out and each name once, without regard to case. The first start of each release that moved them copied each organization's value into its layer once, when the old reader would have used it (a value it read as the deployment's is nothing to copy); the value left on the organization is read by nothing, and `GET /api/v1/orgs` no longer shows it. Until 0.2.0, `PATCH` and `POST /api/v1/orgs` still take them, checked as above, and write them into the organization's layer instead, with every rule of that route (a revision with source `person`, a `settings.updated` audit row, a key with no repository allowlist); `null` takes the key out of the layer, so the organization reads the deployment's value. The answer then carries `deprecated`: one `{"setting", "moved_to", "removed_in", "detail"}` per moved setting it took. 0.2.0 refuses them.
 
 `GET` and `POST /api/v1/orgs/{owner}/webhook` inspect and install the organization's one GitHub webhook, and the receiver's gate handles deliveries for repositories nobody registered ([webhooks.md](webhooks.md#organization-webhooks-github), [ADR 0012](adr/0012-organization-webhook.md)).
 
diff --git a/docs/architecture.md b/docs/architecture.md
index 4c751cce..08461ae0 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1390,6 +1390,7 @@ The whole pass is serialised across processes by a session-level Postgres adviso
 | 141 | the repository of a job posted with a git context alone: fills `jobs.repo` from `context->>'repo'` where `repo` is NULL and the context is git, so `GET /jobs?repo=`, the world view and the stats find it (`POST /jobs` stores it now); a row naming a repository and any other context are left alone, `updated_at` is kept, and a second run changes nothing | `jobs.repo` (data) |
 | 142 | the skills triage may add to an agent: `agent_definitions.triage_may_add_skills`, a JSON array of `source:skill` names (NOT NULL, default `[]`); triage adds one only from a source the agent's skills already load. The built-in developer row gets `superpowers:brainstorming` and `superpowers:writing-plans`, the two the triage prompt always offered it, so an upgraded deployment keeps its behaviour; every other row, and a deployment without that row, gets none | `agent_definitions.triage_may_add_skills` |
 | 143 | behaviour from agent and template rows, not built-in names (#167): `pipeline_templates.fixed_route` (NOT NULL, default false), `offered_to_triage` (NOT NULL, default true), `job_kind` (an override; NULL reads the route), `delivers` (NOT NULL, default `''`) and `leader_agent`; `agent_definitions.station` (NOT NULL, default `desk`) and `quest_template` (NULL none, `''` a task naming no template); `jobs.coding_agent` and `jobs.leader_agent`, which plan_route records and progression credits from. Every row gets what the code said of its name before: the ten specialist templates fixed and not offered, the leaders and deliverables of the old maps, the old stations and guild tasks; a slop-cleanup job coded by the Slopmaster and every job led by its template's old leader. A template named `qa`, `onboard` or `pr-review` is renamed `<name>-template` | `pipeline_templates`, `agent_definitions`, `jobs` |
+| 144 | each Slop-O-Meter score's configuration version: `slop_meter_scores.config_version` (NOT NULL, default `''`), a digest of the `slop_meter` settings the score was computed from (#169). A score stored before it names none, which no digest equals, so the meter's next run rescores it and records one | `slop_meter_scores.config_version` |
 
 Note: LangGraph's checkpoint tables (`checkpoints`, `checkpoint_blobs`, `checkpoint_writes`) are created and mutated by `langgraph-checkpoint-postgres` / `orchestration/checkpoint.py`, outside `embry0_migrations` entirely — they're excluded from this ledger by design, not an oversight.
 
diff --git a/docs/configuration.md b/docs/configuration.md
index 99b0ac62..4f012328 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -162,12 +162,14 @@ Both loops are one brief writer (`embry0/services/brief_writer.py`), each on its
 
 ### Slop-O-Meter
 
+How the [Slop-O-Meter](slop-meter.md) scores, how often it reads and how hard it reads the forge are the settings document's `slop_meter` section ([the reference below](#slop_meter)); the variables left are the process's own limits.
+
 | Variable | Default | Description |
 |----------|---------|-------------|
-| `SLOP_METER_INTERVAL_SECONDS` | `86400` | How often the [Slop-O-Meter](slop-meter.md) reads and scores its repositories; `0` turns it off. The loop is on by default, and reads the repositories enrolled in `background.slop_meter`: none on a new deployment ([which repositories](#which-repositories-background-features-read)) |
+| `SLOP_METER_INTERVAL_SECONDS` | `86400` | Governed by the settings document (`slop_meter.interval_hours`, and `slop_meter.enabled: false` for `0`). Read once, at the first start of the release that added the section, and ignored after that |
 | `SLOP_METER_REPOS` / `SLOP_METER_EXCLUDE` | (empty) | Governed by the settings document (`background.slop_meter`, in each repository's layer). Read once, at the first start of the release that added the `background` section, as `SCOUT_REPOS` and `SCOUT_EXCLUDE` are, and ignored after that |
+| `SLOP_METER_API_CALLS_PER_TICK` / `SLOP_METER_RATE_RESERVE` | `200` / `2000` | Governed by the settings document (`slop_meter.api_calls_per_tick` and `slop_meter.rate_reserve`, which an organization's layer may set). Read once, at the first start of the release that added the section, and ignored after that |
 | `SLOP_METER_CATCHUP_SECONDS` | `300` | How soon the meter comes back while a repository's history is still being read |
-| `SLOP_METER_API_CALLS_PER_TICK` / `SLOP_METER_RATE_RESERVE` | `200` / `2000` | The forge API calls one tick may make with each credential, shared round-robin by the repositories it reads, and that credential's remaining rate limit below which it stops calling (jobs use the same credential). Git fetches are not API calls |
 | `SLOP_METER_DATA_PATH` | `/data/embry0/slop-meter` | Where the meter keeps a bare mirror of each repository, inside the orchestrator's data volume |
 | `SLOP_METER_GIT_TIMEOUT_SECONDS` | `900` | The longest one git clone or fetch of a mirror may take |
 | `SLOP_METER_COMMITS_PER_TICK` / `SLOP_METER_EVENT_PAGES` / `SLOP_METER_REVIEWS_PER_TICK` / `SLOP_METER_LOGINS_PER_TICK` | `5000` / `10` / `50` / `20` | What one tick reads at most per repository: commits of its history, pages of forge events, pull requests' reviews, and logins mapped to commit emails. A larger history is read over several ticks |
@@ -305,7 +307,7 @@ asks:
 - **In the dashboard**, Settings → Policy holds the same three things, for one document at a time. The **Layer** picker above them chooses the deployment's document, an organization's layer or a repository's: it offers every organization and repository the lists show and every stored layer, each marked with how many keys its layer sets, and keeps the choice in the URL (`/settings?tab=policy&owner=acme`, `&repo=acme/widgets`), so a layer can be linked to; an organization's Settings tab and a repository's page link to their own. Picking one with no layer opens an empty one that its first save creates, and picking another while an edit is unsaved asks first. The document is a YAML text box: **Preview** runs the dry run and lists each key the text would change, before and after, with the text diff; **Save** then stores exactly the previewed text, with an optional reason. Both name the generation the edit started from (0 for a layer nobody wrote), so if someone else saved in between they are refused, the new version is read in and your text stays in the box to preview again. A layer lists above its text the keys it may set, per section. A refused document lists every problem next to the text, each with its key, and marks a key the layer may not set. When a save, its preview or an undo makes values of the layers under the document read as inherited (`layers_refused`), the tab lists them, each linked to its layer. Below it, **Values in effect** shows every key of every section with its value, its default and where it came from, and warns when a stored value is refused, an imported variable is still set, or the document holds a section or key this release does not know; for a layer, as that organization or repository reads it: the layer each value comes from, what the layer's own value overrides ("Overrides "09-18" from the deployment"), what it inherits and from whom, and, dimmed, the keys it may not set. **History** lists the document's revisions, opens each one to show what it changed, and offers Undo on the newest. Anyone signed in can read the tab, with the people behind changes shown as the audit log shows them (someone else's name only to an admin); only an admin can preview, save or undo, and an API key with a repository allowlist only on a repository's layer the list covers. A document [kept in a file](#from-a-file-the-command-line-and-mcp) is shown read-only, to an admin too.
 - **From the environment.** When a release moves a feature's policy into a section, the first start of that release imports each of its variables you set, when the value differs from the default, once per key (source `bootstrap`); a key a later release adds to the section is imported at that release's first start. A variable left at its default is not imported, so a default the section changes reaches every deployment that never set it; where a section turns a default the other way on purpose, it declares the value a deployment that relied on the old meaning keeps, and how to tell one from its records (for `leads.enabled`: a registered repository, a job or a lead a finder stored). Only records older than the moment the release first asked about the key count: the import records that moment once in the document's ledger (`leads.enabled@<time>`, the database's clock when the process began, before the migrations), so a repository a new deployment registers while it waits, or between two starts, is never taken for its past. While the variable is not set, such a deployment gets that value written into the document under a comment saying why (`settings_default_kept`, once); a new one does not, and a value an operator has written stands. If that check fails (the database busy at the start), its key reads its default, `settings_bootstrap_check_failed` is logged at error level, and the check is asked again in the same run, after a minute and then at doubling intervals up to fifteen minutes, until it answers (`settings_bootstrap_check_settled`); a restart in between asks at its start, about the same moment. An import that fails outright is tried again in the same run the same way. A part of a variable the section drops, such as an unknown finder name in `LEADS_FINDERS`, is named in a `settings_env_value_dropped` warning. A value the section refuses is skipped with a `settings_bootstrap_value_refused` warning: set it in the document instead. A value refused only together with the section's other stored values is held (`settings_bootstrap_value_held`) and tried again at the next start. After that the variable is ignored: startup logs `settings_env_ignored` and `embry0 config` says the document governs it. The variable is removed one release later. The reference below names the variable each key was imported from.
 - **After a rollback.** A section or a key that a newer release wrote and this one does not know is kept as long as it is sent back exactly as stored (as the stored text has it, or as GET's `data` does), and is listed in `unknown_sections` or `unknown_keys`.
-- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The one exception is `leads.ask_severities`, merged kind by kind: the deployment's document over the default, and an organization's layer over the deployment's. The kinds a document names replace the entries below it; every other kind keeps them (the reference marks it *entry by entry*, and the effective view gives each kind's source in `entries`). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
+- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The two exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
 - **Moved so far**, one section per bullet, in name order:
   - The asks policy (`asks`, from `ASKS_ENABLED` and the `ASK_*` variables): the ask loop reads it every tick and `GET /api/v1/asks/due` on every request, so turning asks on or changing their hours needs no restart. It is read per organization: an ask follows the layer of the organization its decision's repository belongs to for `hours`, `weekdays`, `timezone`, `remind_hours`, `expire_days` and `max_open_per_person`, and the deployment's document for the rest, so a change to an organization's layer applies to its asks on the next tick. An ask about a decision with no repository follows the deployment's document. `max_open_per_person` counts per person within an organization: someone asked about two organizations' decisions may hold each one's number, and the asks about decisions with no repository count apart. `enabled`, `lease_minutes` and `tick_seconds` are the deployment's alone.
   - Which repositories the background features read (`background`, from `SCOUT_REPOS`, `SCOUT_EXCLUDE`, `SLOP_METER_REPOS` and `SLOP_METER_EXCLUDE`, and what the scout and the Slop-O-Meter read before, into the repositories' layers): one switch per feature, `leads`, `scout` and `slop_meter`, which an organization's layer and a repository's layer may each set. A repository is read when it is registered, active and its switch resolves to true; nothing else enrolls it, not a job run on it. The scout and the meter are off until enrolled, and leads read every repository someone answers for unless a layer takes it out. Each loop reads it every tick, so opting a repository out stops it on the next one, and the meter removes what it kept of it `background.prune_after_days` (a week) later unless it comes back first ([which repositories](#which-repositories-background-features-read)).
@@ -316,6 +318,7 @@ asks:
   - The leads policy (`leads`, from `LEADS_ENABLED`, the other `LEADS_*` variables and `PROPOSALS_TICKET_MIN_READINESS`, which is `ask_min`, and `ask_severities`, until now fixed in the code: only a crack or a weed graded high or critical is asked in chat, which stays its default): the leads loop reads it every 5 minutes, and the proposals feed, decision cards, asks and the brief writer on every read, so turning leads on or changing what they read or ask needs no restart. `enabled` defaults to `false` now; a deployment that existed before keeps them on (*From the environment* above). An organization's layer may set the finders, the daily cap, `review_stale_days`, `flaky_commits`, both readiness thresholds and `ask_severities` for its repositories; the readiness labels and weights stay in the code until #168 moves them. What each kind of lead is called stays in the code: it is content, the lead-kind catalogue, not policy ([leads.md](leads.md#what-reaches-chat)).
   - The salvage policy (`salvage`, until now fixed in the code as `wip: unfinished — <agent> stopped (<reason>)`): the subject of the commit that keeps a stopped coding run's work, as a template naming `{agent}` and `{reason}`, so a repository whose commit rules refuse `wip:` can write what they accept. A subject past 100 characters has only its reason shortened. An organization's or a repository's layer may set it, and a coding job reads it when it starts, as it reads `done_when`.
   - The scout's policy (`scout`, from `SCOUT_TEMPLATES`, `SCOUT_MAX_IN_FLIGHT`, `SCOUT_REVISIT_HOURS` and `SCOUT_MAX_LEADS_PER_JOB`, plus each job's hard cap, until now fixed at 1 USD, and a daily cap, off by default): the scout reads it every tick, so a change applies within 5 minutes with no restart. Which repositories it reads is `background.scout` (above).
+  - The Slop-O-Meter's scoring policy and pace (`slop_meter`, from `SLOP_METER_INTERVAL_SECONDS`, which is `interval_hours`, or `enabled: false` for `0`, `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE`; everything else was fixed in the meter's code, and its defaults are those values, so a deployment that writes nothing scores exactly as before): what a changed line of each kind of file weighs (`weights`, merged glob by glob), which directories are vendored and what is a test, the hours a commit, a co-author or a comment implies, the lines an hour covers and the weekly cap, who counts as the core team and the small-repository rule, the outlier thresholds and what the judge is told, the five levels' bounds and names, and the owner's own bots and AI agents. An organization's layer may set every key but `enabled` and `interval_hours`, and a repository's what counts as code in its layout. Each organization's `slop_meter_bots` was copied into its layer as `bots` once; `PATCH /api/v1/orgs/{owner}` still takes it until 0.2.0. Every score records the version of the settings it was computed with, and the meter looks at the section every 5 minutes, so a change to what a score is computed from rescores the repositories it reaches at once rather than at the next daily run ([how a change rescores](slop-meter.md#how-a-change-rescores)). The variables left (`SLOP_METER_CATCHUP_SECONDS`, `_DATA_PATH`, `_GIT_TIMEOUT_SECONDS`, `_COMMITS_PER_TICK`, `_EVENT_PAGES`, `_REVIEWS_PER_TICK`, `_LOGINS_PER_TICK`, `_JUDGMENTS_PER_TICK`) are the process's own limits.
   - The dashboard's game layer and home page (`ui`, new: no variable configured them). The game is on and the guild is the home until a document says otherwise. The dashboard reads the section before it draws its navigation and home page, every minute after that and at once after a save on the Policy tab, and `GET /api/v1/config/ui` and the game's routes read it on every request, so turning the game off or on needs no restart and no reload. The deployment's only: the dashboard knows no viewer's organization to read a layer for. See [turning the game off](world.md#turning-the-game-off).
 
 ### Which repositories background features read
@@ -539,6 +542,42 @@ What the scout runs, how often it comes back to a repository, and how much it ma
 | `job_budget_usd` | number | `1.0` | > 0, ≤ 1000 |  |  | The hard cap of one scouting job, in US dollars. A job pinned to the local model bills nothing; this stops one whose pin is ever lost. |
 | `max_jobs_per_day` | whole number or null | `null` | ≥ 0, ≤ 10000 |  |  | Most scouting jobs started in any 24 hours; null sets no cap, and 0 starts none. |
 
+#### `slop_meter`
+
+How the Slop-O-Meter weighs a changed line and a person's attention, where its levels fall, which identities are bots, and how often and how hard it reads the forge.
+
+| Key | Type | Default | Allowed | Overridable by | Imported from | Description |
+|---|---|---|---|---|---|---|
+| `enabled` | true or false | `true` |  |  | `SLOP_METER_INTERVAL_SECONDS` | The meter reads the repositories enrolled in background.slop_meter and scores them. false stops the reading and the scoring everywhere; what was kept of a repository that left the scope is still removed after background.prune_after_days. Was SLOP_METER_INTERVAL_SECONDS=0. The deployment's alone. |
+| `interval_hours` | number | `24.0` | ≥ 0.25, ≤ 8760 |  | `SLOP_METER_INTERVAL_SECONDS` | Hours between two runs over every enrolled repository: fetch, read the next part of its history and events, and rescore it once caught up. While a history is still being read the meter comes back sooner (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At least a quarter hour. Was SLOP_METER_INTERVAL_SECONDS. The deployment's alone. |
+| `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins. Where repositories of organizations that set different values are read with one credential, the smallest applies. Git fetches are not API calls. |
+| `rate_reserve` | whole number | `2000` | ≥ 0, ≤ 100000 | organization | `SLOP_METER_RATE_RESERVE` | The rate limit a credential keeps for the jobs that use it: once its remaining calls (X-RateLimit-Remaining) drop below this, the run makes no further call with it. Where organizations that set different values share one credential, the largest applies. |
+| `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the longest glob wins (*.min.js over *.js). Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting. |
+| `excluded_dirs` | list of text | `["vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files weigh nothing, each one name matched at any depth: vendored and third-party code. A list replaces the one it inherits whole; [] excludes none. |
+| `test_dirs` | list of text | `["__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample", "fixtures", "testdata"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files are tests or examples, each one name matched at any depth: their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
+| `test_files` | list of text | `["*_test.go", "*_test.py", "*_test.rb", "*_test.ex", "*_test.exs", "*_spec.rb", "test_?*.py"]` | at most 200 entries, each at most 200 characters | organization, repository |  | Globs of test and example files, in the grammar of weights (*_test.go, test_?*.py): their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
+| `test_marks` | list of text | `["test", "spec", "stories", "story"]` | at most 50 entries, each at most 50 characters | organization, repository |  | Words that mark a test or example file when they come just before its extension: test marks a.test.ts and b.test.py, but not a.test.helper.ts. Their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
+| `test_weight` | number | `0.5` | ≥ 0, ≤ 1 | organization |  | A test or example file's lines weigh this share of what their file's glob in weights says. |
+| `bootstrap_lines` | whole number | `5000` | ≥ 1, ≤ 10000000 | organization |  | Size dampening: while a codebase holds fewer weighted lines than this, a week's lines cost in proportion to its size, so a young project's first lines cost little; from this size on, in full. |
+| `complexity_weight` | number | `0.05` | ≥ 0, ≤ 1 | organization |  | Size dampening: how much more a line costs as the codebase grows, per doubling past 100,000 weighted lines (the cost is min(1, size / bootstrap_lines) + complexity_weight × log2(1 + size / 100,000)). |
+| `commit_hours` | number | `1.0` | > 0, ≤ 24 | organization |  | Hours of a person's attention each commit they author implies, before its time. |
+| `subcommit_hours` | number | `1.0` | ≥ 0, ≤ 24 | organization |  | Hours more for each commit a squash merge folded in (a body that lists two or more bullet lines). |
+| `coauthor_shares` | list of number | `[0.5, 0.25, 0.125]` | at least 1 entries, at most 10 entries | organization |  | Each human Co-authored-by trailer implies this share of commit_hours, in trailer order; the last share applies to every co-author after it. Each from 0 to 1. |
+| `ai_coauthor_share` | number | `0.8` | ≥ 0, ≤ 1 | organization |  | A commit with an AI co-author implies this share of the hours its author's commit would. |
+| `event_hours` | number | `1.0` | ≥ 0, ≤ 24 | organization |  | Hours of attention each comment, review comment and review on the forge implies (GitHub only). |
+| `lines_per_hour` | number | `40.0` | > 0, ≤ 10000 | organization |  | Weighted lines one hour of a person's attention covers. |
+| `weekly_hours_cap` | number | `80.0` | > 0, ≤ 168 | organization |  | The most hours one person's week counts, on a concave curve (h − h³/(3·cap²)), so overtime counts for less and nothing past the cap. |
+| `core_min_commits` | whole number | `10` | ≥ 0, ≤ 100000 | organization |  | Authors with fewer human commits than this are drive-bys: their time counts for nothing. Their share rises to full at core_full_commits, and up to a quarter more for a large share of the history. |
+| `core_full_commits` | whole number | `60` | ≥ 1, ≤ 100000 | organization |  | The human commits at which an author's time counts in full. More than core_min_commits. |
+| `small_repository_in_full` | true or false | `true` |  | organization |  | When no author has reached core_min_commits, everyone's time counts in full: a small repository has no core team to call anyone a drive-by, and read literally every author of it counts for nothing and all its code reads as slop. embry0's departure from the published algorithm; false scores such a repository as the algorithm is written. |
+| `outlier_min_lines` | whole number | `2000` | ≥ 1, ≤ 10000000 | organization |  | Net weighted lines a commit must add to be an outlier, judged by a model on background_models.slop_judge: slop, or a code drop, an import or a move that is not. |
+| `outliers_per_year` | whole number | `4` | ≥ 0, ≤ 365 | organization |  | Outlier commits judged per year of the project's age, the largest first; at least one however young. |
+| `judge_prompt` | text | `"You judge one large commit of a software repository: did it add bulk code no\nperson wrote or reviewed line by line (slop, such as a large AI-generated\nchange), or is its size explained by something else (not slop: the project's\ninitial import, a code drop moved in from elsewhere, a restructuring that moved\nfiles, a vendored or generated library, a data or fixture dump)?\nJudge from what the message and the files say. When it is unclear, answer\nslop: false only if the files themselves look moved, vendored or generated."` | at least 1 characters, at most 4000 characters | organization |  | What the model judging an outlier commit is told slop is and is not. The answer's form (JSON with slop and a reason) is added after it. Applies to commits judged after it changes: a judgment is kept and never asked again, so a change rescores nothing. |
+| `level_bounds` | list of number | `[0.2, 0.4, 0.6, 0.8]` | at least 4 entries, at most 4 entries | organization |  | Where the five levels part: a score below the first bound is level 1, below the second level 2, and so on; at or above the last, level 5. Four bounds, each above the one before, from 0 to 1. |
+| `level_names` | list of text | `["Buttered Noodles", "Spaghetti Bolognese", "Lasagna", "Sloppy Joe", "Just The Slop"]` | at least 5 entries, at most 5 entries, each at most 60 characters | organization |  | The five levels' names, level 1 (the least slop) first. Each one line, each named once. |
+| `bots` | list of text | `[]` | at most 100 entries, each at most 200 characters | organization |  | The owner's own bots, as commit names, addresses or forge logins matched whole without regard to case: their commits add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit identities. Was the organization's slop_meter_bots. |
+| `ai_agents` | list of text | `[]` | at most 100 entries, each at most 200 characters | organization |  | AI coding agents beyond the known ones, as the start of their commit address (aider@), matched without regard to case: a commit one authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's hours. |
+
 #### `ui`
 
 What the dashboard shows: the game layer, and the page it opens on.
diff --git a/docs/examples/settings.yaml b/docs/examples/settings.yaml
index e25f551b..e6b0e0de 100644
--- a/docs/examples/settings.yaml
+++ b/docs/examples/settings.yaml
@@ -396,6 +396,294 @@ scout:
   # none.
   # max_jobs_per_day: null
 
+# How the Slop-O-Meter weighs a changed line and a person's attention, where
+# its levels fall, which identities are bots, and how often and how hard it
+# reads the forge.
+slop_meter:
+  # The meter reads the repositories enrolled in background.slop_meter and
+  # scores them. false stops the reading and the scoring everywhere; what was
+  # kept of a repository that left the scope is still removed after
+  # background.prune_after_days. Was SLOP_METER_INTERVAL_SECONDS=0. The
+  # deployment's alone.
+  # enabled: true
+
+  # Hours between two runs over every enrolled repository: fetch, read the
+  # next part of its history and events, and rescore it once caught up. While
+  # a history is still being read the meter comes back sooner
+  # (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At
+  # least a quarter hour. Was SLOP_METER_INTERVAL_SECONDS. The deployment's
+  # alone.
+  # interval_hours: 24.0
+
+  # Forge API calls one run may make with one credential, shared round-robin
+  # by the repositories read with it, to read comments, reviews and logins.
+  # Where repositories of organizations that set different values are read
+  # with one credential, the smallest applies. Git fetches are not API calls.
+  # api_calls_per_tick: 200
+
+  # The rate limit a credential keeps for the jobs that use it: once its
+  # remaining calls (X-RateLimit-Remaining) drop below this, the run makes no
+  # further call with it. Where organizations that set different values share
+  # one credential, the largest applies.
+  # rate_reserve: 2000
+
+  # What one changed line of a file weighs, by glob, from 0 to 10; a file no
+  # glob matches weighs 0, so data, documents and binaries never count. A glob
+  # with no '/' matches a file's name in any directory (*.py), one with a '/'
+  # its path from the repository's root (db/migrations/*.sql, generated/**);
+  # '*' matches within one name, '?' one character, '**' any directories.
+  # Where several match, the longest glob wins (*.min.js over *.js). Write
+  # globs in lowercase, quoted: matching ignores case, and YAML reads a bare *
+  # as an alias. Merged entry by entry: a document adds or changes the globs
+  # it names and keeps every other, so a glob set to 0 stops counting.
+  # weights:
+  #   '*.py': 1.0
+  #   '*.pyi': 1.0
+  #   '*.ts': 1.0
+  #   '*.mts': 1.0
+  #   '*.cts': 1.0
+  #   '*.js': 1.0
+  #   '*.mjs': 1.0
+  #   '*.cjs': 1.0
+  #   '*.go': 1.0
+  #   '*.rs': 1.0
+  #   '*.java': 1.0
+  #   '*.kt': 1.0
+  #   '*.kts': 1.0
+  #   '*.scala': 1.0
+  #   '*.c': 1.0
+  #   '*.h': 1.0
+  #   '*.cc': 1.0
+  #   '*.cpp': 1.0
+  #   '*.cxx': 1.0
+  #   '*.hpp': 1.0
+  #   '*.hh': 1.0
+  #   '*.cs': 1.0
+  #   '*.rb': 1.0
+  #   '*.php': 1.0
+  #   '*.swift': 1.0
+  #   '*.m': 1.0
+  #   '*.mm': 1.0
+  #   '*.ex': 1.0
+  #   '*.exs': 1.0
+  #   '*.erl': 1.0
+  #   '*.clj': 1.0
+  #   '*.cljs': 1.0
+  #   '*.hs': 1.0
+  #   '*.ml': 1.0
+  #   '*.fs': 1.0
+  #   '*.lua': 1.0
+  #   '*.pl': 1.0
+  #   '*.pm': 1.0
+  #   '*.r': 1.0
+  #   '*.jl': 1.0
+  #   '*.dart': 1.0
+  #   '*.zig': 1.0
+  #   '*.nim': 1.0
+  #   '*.groovy': 1.0
+  #   '*.sh': 1.0
+  #   '*.bash': 1.0
+  #   '*.zsh': 1.0
+  #   '*.ps1': 1.0
+  #   '*.tf': 1.0
+  #   '*.sol': 1.0
+  #   '*.proto': 1.0
+  #   '*.graphql': 1.0
+  #   '*.gql': 1.0
+  #   '*.sql': 0.8
+  #   '*.tsx': 0.5
+  #   '*.jsx': 0.5
+  #   '*.vue': 0.5
+  #   '*.svelte': 0.5
+  #   '*.astro': 0.5
+  #   '*.html': 0.5
+  #   '*.htm': 0.5
+  #   '*.erb': 0.5
+  #   '*.hbs': 0.5
+  #   '*.ejs': 0.5
+  #   '*.jinja': 0.5
+  #   '*.j2': 0.5
+  #   '*.twig': 0.5
+  #   '*.liquid': 0.5
+  #   '*.css': 0.3
+  #   '*.scss': 0.3
+  #   '*.sass': 0.3
+  #   '*.less': 0.3
+  #   '*.styl': 0.3
+  #   '*.pcss': 0.3
+  #   '*.min.js': 0.0
+  #   '*.min.css': 0.0
+  #   '*.bundle.js': 0.0
+  #   '*.map': 0.0
+  #   '*.d.ts': 0.0
+
+  # Directories whose files weigh nothing, each one name matched at any depth:
+  # vendored and third-party code. A list replaces the one it inherits whole;
+  # [] excludes none.
+  # excluded_dirs:
+  # - vendor
+  # - node_modules
+  # - third_party
+  # - third-party
+  # - external
+  # - deps
+  # - bower_components
+
+  # Directories whose files are tests or examples, each one name matched at
+  # any depth: their lines weigh test_weight of what weights says. A list
+  # replaces the one it inherits whole.
+  # test_dirs:
+  # - __tests__
+  # - tests
+  # - test
+  # - spec
+  # - specs
+  # - examples
+  # - example
+  # - demos
+  # - demo
+  # - samples
+  # - sample
+  # - fixtures
+  # - testdata
+
+  # Globs of test and example files, in the grammar of weights (*_test.go,
+  # test_?*.py): their lines weigh test_weight of what weights says. A list
+  # replaces the one it inherits whole.
+  # test_files:
+  # - '*_test.go'
+  # - '*_test.py'
+  # - '*_test.rb'
+  # - '*_test.ex'
+  # - '*_test.exs'
+  # - '*_spec.rb'
+  # - test_?*.py
+
+  # Words that mark a test or example file when they come just before its
+  # extension: test marks a.test.ts and b.test.py, but not a.test.helper.ts.
+  # Their lines weigh test_weight of what weights says. A list replaces the
+  # one it inherits whole.
+  # test_marks:
+  # - test
+  # - spec
+  # - stories
+  # - story
+
+  # A test or example file's lines weigh this share of what their file's glob
+  # in weights says.
+  # test_weight: 0.5
+
+  # Size dampening: while a codebase holds fewer weighted lines than this, a
+  # week's lines cost in proportion to its size, so a young project's first
+  # lines cost little; from this size on, in full.
+  # bootstrap_lines: 5000
+
+  # Size dampening: how much more a line costs as the codebase grows, per
+  # doubling past 100,000 weighted lines (the cost is min(1, size /
+  # bootstrap_lines) + complexity_weight × log2(1 + size / 100,000)).
+  # complexity_weight: 0.05
+
+  # Hours of a person's attention each commit they author implies, before its
+  # time.
+  # commit_hours: 1.0
+
+  # Hours more for each commit a squash merge folded in (a body that lists two
+  # or more bullet lines).
+  # subcommit_hours: 1.0
+
+  # Each human Co-authored-by trailer implies this share of commit_hours, in
+  # trailer order; the last share applies to every co-author after it. Each
+  # from 0 to 1.
+  # coauthor_shares:
+  # - 0.5
+  # - 0.25
+  # - 0.125
+
+  # A commit with an AI co-author implies this share of the hours its author's
+  # commit would.
+  # ai_coauthor_share: 0.8
+
+  # Hours of attention each comment, review comment and review on the forge
+  # implies (GitHub only).
+  # event_hours: 1.0
+
+  # Weighted lines one hour of a person's attention covers.
+  # lines_per_hour: 40.0
+
+  # The most hours one person's week counts, on a concave curve (h −
+  # h³/(3·cap²)), so overtime counts for less and nothing past the cap.
+  # weekly_hours_cap: 80.0
+
+  # Authors with fewer human commits than this are drive-bys: their time
+  # counts for nothing. Their share rises to full at core_full_commits, and up
+  # to a quarter more for a large share of the history.
+  # core_min_commits: 10
+
+  # The human commits at which an author's time counts in full. More than
+  # core_min_commits.
+  # core_full_commits: 60
+
+  # When no author has reached core_min_commits, everyone's time counts in
+  # full: a small repository has no core team to call anyone a drive-by, and
+  # read literally every author of it counts for nothing and all its code
+  # reads as slop. embry0's departure from the published algorithm; false
+  # scores such a repository as the algorithm is written.
+  # small_repository_in_full: true
+
+  # Net weighted lines a commit must add to be an outlier, judged by a model
+  # on background_models.slop_judge: slop, or a code drop, an import or a move
+  # that is not.
+  # outlier_min_lines: 2000
+
+  # Outlier commits judged per year of the project's age, the largest first;
+  # at least one however young.
+  # outliers_per_year: 4
+
+  # What the model judging an outlier commit is told slop is and is not. The
+  # answer's form (JSON with slop and a reason) is added after it. Applies to
+  # commits judged after it changes: a judgment is kept and never asked again,
+  # so a change rescores nothing.
+  # judge_prompt: |-
+  #   You judge one large commit of a software repository: did it add bulk code no
+  #   person wrote or reviewed line by line (slop, such as a large AI-generated
+  #   change), or is its size explained by something else (not slop: the project's
+  #   initial import, a code drop moved in from elsewhere, a restructuring that moved
+  #   files, a vendored or generated library, a data or fixture dump)?
+  #   Judge from what the message and the files say. When it is unclear, answer
+  #   slop: false only if the files themselves look moved, vendored or generated.
+
+  # Where the five levels part: a score below the first bound is level 1,
+  # below the second level 2, and so on; at or above the last, level 5. Four
+  # bounds, each above the one before, from 0 to 1.
+  # level_bounds:
+  # - 0.2
+  # - 0.4
+  # - 0.6
+  # - 0.8
+
+  # The five levels' names, level 1 (the least slop) first. Each one line,
+  # each named once.
+  # level_names:
+  # - Buttered Noodles
+  # - Spaghetti Bolognese
+  # - Lasagna
+  # - Sloppy Joe
+  # - Just The Slop
+
+  # The owner's own bots, as commit names, addresses or forge logins matched
+  # whole without regard to case: their commits add lines but no attention,
+  # and as a co-author they count as an AI agent does. Beyond the ones every
+  # deployment knows ([bot] accounts, noreply@ addresses, known coding agents)
+  # and embry0's own commit identities. Was the organization's
+  # slop_meter_bots.
+  # bots: []
+
+  # AI coding agents beyond the known ones, as the start of their commit
+  # address (aider@), matched without regard to case: a commit one authors
+  # adds lines but no attention, and one it co-authors counts
+  # ai_coauthor_share of its author's hours.
+  # ai_agents: []
+
 # What the dashboard shows: the game layer, and the page it opens on.
 ui:
   # Show the game layer: the guild, the agents' levels, skills and outfits,
diff --git a/docs/glossary.md b/docs/glossary.md
index aeeb16e9..e279db3b 100644
--- a/docs/glossary.md
+++ b/docs/glossary.md
@@ -196,7 +196,7 @@ What the slopometer calls a finding or a code job whose code does what it says,
 The world map's place for a repository's or an area's open [slop](#slop): a cave beside its town (or its region), with a slop score that is `100 × (1 − Π(1 − sᵢ/100))` over its open slop's scores, so it rises with one heavy item or many light ones and falls as each is cleaned, and the count of cleanups merged in it in the last 30 days. A slop finding on the quest board is a `slop` lead (verb **Clean up**, an ooze) led by the Slopmaster. Each dungeon carries its area's [Slop-O-Meter](#slop-o-meter) reading, and an area that reads Spaghetti Bolognese or worse has a dungeon even with no open finding. (2026-10)
 
 ### Slop-O-Meter
-How much of a repository's (or an area's) code landed beyond human attention, after [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm, reimplemented from that description. Each week's **attention cost** is its net weighted additions (lines weighed by file type, half for tests, nothing for non-code, vendored, generated, linter-ignored or small outlier files), dampened by the codebase's size; its **capacity** is the human session time behind it (commits, co-authors, squash merges, comments and reviews, bots left out, each contributor's hours weighed by how core they are and capped concavely at 80 a week) at 40 lines an hour. The excess is slop, and the score is the history's slop over its cost: Buttered Noodles (< 0.2), Spaghetti Bolognese, Lasagna, Sloppy Joe, Just The Slop (≥ 0.8). Outlier commits (thousands of lines at once) are judged by a model; until one is, the score is **provisional**. Read daily for the repositories enrolled in `background.slop_meter` of the settings document, from a bare mirror and the forge's events under a per-tick API budget that stops at a rate-limit reserve; triage and the Slopmaster are told the job's area's reading. Spec: `docs/superpowers/specs/2026-10-26-slop-o-meter-design.md`. (2026-10)
+How much of a repository's (or an area's) code landed beyond human attention, after [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm, reimplemented from that description. Each week's **attention cost** is its net weighted additions (lines weighed by file type, half for tests, nothing for non-code, vendored, generated, linter-ignored or small outlier files), dampened by the codebase's size; its **capacity** is the human session time behind it (commits, co-authors, squash merges, comments and reviews, bots left out, each contributor's hours weighed by how core they are and capped concavely at 80 a week) at 40 lines an hour. The excess is slop, and the score is the history's slop over its cost, read as one of five levels: by default Buttered Noodles (< 0.2), Spaghetti Bolognese, Lasagna, Sloppy Joe, Just The Slop (≥ 0.8). Every weight, rate, threshold and level is the `slop_meter` section of the settings document, an organization's layer over the deployment's, its defaults the published values; each score records the version of the settings it was computed with, and a change rescores within five minutes. Outlier commits (thousands of lines at once) are judged by a model; until one is, the score is **provisional**. Read daily (`slop_meter.interval_hours`) for the repositories enrolled in `background.slop_meter` of the settings document, from a bare mirror and the forge's events under a per-tick API budget that stops at a rate-limit reserve; triage and the Slopmaster are told the job's area's reading. Spec: `docs/superpowers/specs/2026-10-26-slop-o-meter-design.md`. (2026-10)
 
 ### Game layer
 The dashboard's game: the guild ([world.md](world.md)), the characters' levels, skills and outfits, the achievements and the chat box ([progression.md](progression.md)), the Settings page's Game content tab, and the routes that serve them (`/world`, `/progression`). On by default; `ui.game: false` in the [settings document](#settings-document) turns it off for the deployment, and the dashboard then opens on the Overview. Reviewing a job is not part of it. See [world.md](world.md#turning-the-game-off). (2026-10)
diff --git a/docs/slop-meter.md b/docs/slop-meter.md
index bc419e08..505289e8 100644
--- a/docs/slop-meter.md
+++ b/docs/slop-meter.md
@@ -2,19 +2,86 @@
 
 The Slop-O-Meter scores how much of a repository, and of each of its areas, landed beyond human attention. Week by week it compares the attention the code demands (its changed lines, weighted by kind of file and dampened by the codebase's size) with the attention it received (people's commits, co-authorship, comments and reviews), and calls the excess slop. The score is the history's slop over its cost, from 0 to 1.
 
-It is a clean-room reimplementation of [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm, written from its description alone. Every choice the description leaves open, and the two places embry0 departs from it, are in [the design](superpowers/specs/2026-10-26-slop-o-meter-design.md).
+It is a clean-room reimplementation of [Slop-O-Meter](https://github.com/slop-o-meter/slop-o-meter)'s published slop score algorithm, written from its description alone. Every choice the description leaves open, and the two places embry0 departs from it, are in [the design](superpowers/specs/2026-10-26-slop-o-meter-design.md). Every number the algorithm names is a key of the settings document's `slop_meter` section ([settings](#settings)), and each default is the algorithm's value, so a deployment that writes nothing scores exactly as the algorithm does, with embry0's two departures.
 
-## Levels
+## What it measures
+
+- **Attention cost.** Each changed line weighs what its file's glob says (`weights`: core logic 1, SQL 0.8, user interface code 0.5, styling 0.3; data, documents, binaries and anything no glob matches 0), a share of that for tests and examples (`test_weight`, a half), and nothing in a vendored directory (`excluded_dirs`), in a generated file (minified, bundled, source-map and declaration files weigh 0 in `weights`), in a path a linter or formatter of the repository ignores, or in an outlier file smaller than its fair share. A week's net weighted additions are dampened by the codebase's size: `min(1, size / bootstrap_lines) + complexity_weight × log2(1 + size / 100,000)`.
+- **Capacity.** Each human commit implies `commit_hours` of attention before it, plus `subcommit_hours` for each commit a squash merge folded in, times `ai_coauthor_share` with an AI co-author; each human co-author `coauthor_shares` of that; each comment, review comment and review on the forge `event_hours`. A contributor's spans are merged into sessions, weighed by how core they are (nothing below `core_min_commits` human commits, in full from `core_full_commits`, up to a quarter more for a large share), capped on a concave curve at `weekly_hours_cap` a week, and turned into lines at `lines_per_hour`.
+- **Slop and the score.** A week's slop is its cost beyond its capacity; the score is the history's slop over its cost.
+- **Outlier commits.** The largest commits (at least `outlier_min_lines` net weighted lines, `outliers_per_year` per year of the project's age, at least one) are asked of a model, one by one: slop, or a code drop, an import or a move that is not. A commit judged not slop keeps its lines in the cost and the codebase's size, but not in the slop. The first two commits are never slop.
+- **Bots and AI agents** add lines but no attention: known bot names and addresses, `[bot]` accounts, `noreply@` addresses, known coding agents' addresses, embry0's own commit identities, and the owner's own `bots` and `ai_agents`. An AI co-author makes its commit an AI-assisted one.
+
+### Levels
+
+A score reads as one of five levels. Their bounds and names are `level_bounds` and `level_names`; by default:
 
 | Score | Level |
 |---|---|
-| below 0.2 | Buttered Noodles |
-| below 0.4 | Spaghetti Bolognese |
-| below 0.6 | Lasagna |
-| below 0.8 | Sloppy Joe |
-| 0.8 and above | Just The Slop |
-
-A score is **provisional** while some of its largest commits (the outliers) are not judged yet. A model judges a few a tick, on `background_models.slop_judge` of the settings document, else its default ([background models](providers.md#background-models)); with no model, they stay unjudged and count as not slop. A judgment on a hosted model is counted against the budget caps, and refused past them.
+| below 0.2 | 1, Buttered Noodles |
+| below 0.4 | 2, Spaghetti Bolognese |
+| below 0.6 | 3, Lasagna |
+| below 0.8 | 4, Sloppy Joe |
+| 0.8 and above | 5, Just The Slop |
+
+A score is **provisional** while some of its outlier commits are not judged yet. A model judges a few a tick, on `background_models.slop_judge` of the settings document, else its default ([background models](providers.md#background-models)); with no model, they stay unjudged and count as not slop. A judgment on a hosted model is counted against the budget caps, and refused past them.
+
+### embry0's departures from the published algorithm
+
+- **Small repositories** (`small_repository_in_full`, on by default). When no author has reached `core_min_commits` human commits, everyone's time counts in full: read literally, the core factor makes every author of a small repository a drive-by worth nothing, so a six-commit, 778-line repository read as Just The Slop. A fast big dump still reads high. `small_repository_in_full: false` scores such a repository as the algorithm is written.
+- **At least one outlier.** A history that spans no time (one commit) still has one outlier judged, so its first commit, setup the algorithm always excuses, is excused.
+
+## Settings
+
+The `slop_meter` section of the settings document ([settings document](configuration.md#settings-document); every key, its bounds and the variable it was imported from are in the [reference](configuration.md#slop_meter)). An operator writes only what differs:
+
+```yaml
+slop_meter:
+  interval_hours: 12          # score twice a day
+  weights:                    # merged entry by entry over the defaults
+    "*.sql": 1.0              # SQL is core logic here
+    "db/migrations/**": 0     # generated migrations weigh nothing
+  lines_per_hour: 30
+  level_names: [Clean, Fine, Mixed, Sloppy, Slop]
+  bots: [release-bot, ci@acme.example]
+```
+
+| Key | Default | What it says |
+|---|---|---|
+| `enabled` | `true` | Whether the meter reads and scores at all. Off, it still removes what it kept of a repository that left its scope |
+| `interval_hours` | `24` | Hours between two runs over every enrolled repository, at least a quarter hour |
+| `api_calls_per_tick` | `200` | Forge API calls one run makes with one credential |
+| `rate_reserve` | `2000` | The rate limit a credential keeps for jobs: below it, the run calls the forge no more with it |
+| `weights` | the published file types | What a changed line weighs, by glob, from 0 to 10 |
+| `excluded_dirs` | `vendor`, `node_modules`, `third_party`, `third-party`, `external`, `deps`, `bower_components` | Directories whose files weigh nothing |
+| `test_dirs` | `__tests__`, `tests`, `test`, `spec`, `specs`, `examples`, `example`, `demos`, `demo`, `samples`, `sample`, `fixtures`, `testdata` | Directories of tests and examples |
+| `test_files` | `*_test.go`, `*_test.py`, `*_test.rb`, `*_test.ex`, `*_test.exs`, `*_spec.rb`, `test_?*.py` | Globs of test and example files |
+| `test_marks` | `test`, `spec`, `stories`, `story` | Words before a file's extension that mark it a test: `a.test.ts` |
+| `test_weight` | `0.5` | A test's lines weigh this share of their glob's weight |
+| `bootstrap_lines`, `complexity_weight` | `5000`, `0.05` | The size dampening |
+| `commit_hours`, `subcommit_hours`, `event_hours` | `1`, `1`, `1` | Hours of attention a commit, a folded commit and a forge event imply |
+| `coauthor_shares`, `ai_coauthor_share` | `[0.5, 0.25, 0.125]`, `0.8` | A co-author's share of a commit's hours, in trailer order, and an AI-assisted commit's share |
+| `lines_per_hour` | `40` | Weighted lines an hour of attention covers |
+| `weekly_hours_cap` | `80` | The most hours a person's week counts |
+| `core_min_commits`, `core_full_commits` | `10`, `60` | The core team's ramp |
+| `small_repository_in_full` | `true` | embry0's small-repository departure |
+| `outlier_min_lines`, `outliers_per_year` | `2000`, `4` | Which commits are outliers |
+| `judge_prompt` | what the model is told slop is | The judge's guidance; the answer's form is added after it |
+| `level_bounds`, `level_names` | `[0.2, 0.4, 0.6, 0.8]`, the five names above | The levels |
+| `bots` | none | The owner's own bots, by commit name, address or forge login |
+| `ai_agents` | none | AI coding agents beyond the known ones, by the start of their commit address (`aider@`) |
+
+**Globs.** A glob with no `/` matches a file's name in any directory (`*.py`); one with a `/` matches its path from the repository's root (`db/migrations/*.sql`, `generated/**`). `*` matches within one name, `?` one character, `**` any number of directories. Matching ignores case, so globs are written in lowercase, and quoted in YAML, which reads a bare `*` as an alias. Where several globs of `weights` match a file, the longest wins (`*.min.js` over `*.js`), and between two of one length the first in alphabetical order. A file no glob matches weighs nothing.
+
+**Layers.** An organization's layer may set every key but `enabled` and `interval_hours`, for its repositories: what counts as code, how fast its team attends to it, where its levels fall, its judge's guidance, its own bots and the forge budget of the credential it reads with. A repository's layer may set what counts as code in its own layout: `weights`, `excluded_dirs`, `test_dirs`, `test_files` and `test_marks`. `weights` is merged glob by glob, through every layer: a document adds or changes the globs it names and keeps every other, so a glob set to `0` stops counting. Every other key a layer sets replaces the inherited value whole. Where repositories of organizations that set different forge budgets are read with one credential, the fewest calls and the largest reserve apply, since the rate limit is the credential's.
+
+**Before this section.** `SLOP_METER_INTERVAL_SECONDS` (`0` turned the reading off), `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE` are imported once, at the first start of the release that added the section, as `interval_hours` (or `enabled: false`), `api_calls_per_tick` and `rate_reserve`, and ignored after that. Each organization's `slop_meter_bots` was copied into its layer as `bots` ([api.md](api.md#organizations)). Everything else was a constant in the meter's code, and its default is that constant.
+
+## How a change rescores
+
+Each score row records `config_version`: a digest of every key its repository's score is computed from, as that repository reads them through its organization's layer and its own. The meter looks at the section every five minutes. When a repository it read last reads another version (an operator changed a weight, a level, the pace, the bots), the meter runs at once, without waiting for `interval_hours`, rescores it and records the new version; undoing the change rescores it back. `GET /api/v1/repos/{repo}/-/slop-meter` shows the version of the repository's score in `reading.config_version` ([api.md](api.md)).
+
+Four keys are not what a score is computed from, and change no version: `enabled`, `interval_hours`, `api_calls_per_tick` and `rate_reserve`. Neither does `judge_prompt`: a judgment is kept per commit and never asked again, so new guidance applies to the outlier commits judged after it, and a change to the weights that makes another commit an outlier has that one judged. A repository still reading its history is scored once it is caught up.
 
 ## Which repositories
 
@@ -22,23 +89,22 @@ The meter reads the registered, active repositories enrolled in it: `background.
 
 A repository that leaves the meter's scope, opted out or unregistered, loses its mirror and everything the meter kept of it `background.prune_after_days` (a week) later, unless it comes back first; one made inactive is not read and keeps what was read ([what it keeps](#what-it-keeps)).
 
-The loop is on by default and reads what is enrolled. `SLOP_METER_INTERVAL_SECONDS=0` turns the reading off.
+The loop is on by default and reads what is enrolled. `slop_meter.enabled: false` turns the reading off; turned on again, the meter reads within five minutes.
 
 ## What it reads, and how much
 
-- **History:** a bare mirror of each repository, cloned and fetched with its organization's forge credential (passed to git through the environment, never in a URL or the mirror's config). Each tick reads at most `SLOP_METER_COMMITS_PER_TICK` commits of a history, oldest first, so a large history is read over several ticks; the loop comes back after `SLOP_METER_CATCHUP_SECONDS` while one is behind. Every git call has a timeout (`SLOP_METER_GIT_TIMEOUT_SECONDS`).
-- **Forge events** (GitHub only): issue and pull request comments, review comments and reviews, from a cursor per listing. These are API calls, bounded per tick (`SLOP_METER_API_CALLS_PER_TICK`) and stopped once the credential's remaining rate limit drops below `SLOP_METER_RATE_RESERVE`, because jobs use the same credential. Git fetches are not API calls.
-- **Bots and AI agents** (known bot names and addresses, `[bot]` accounts, `noreply@` addresses, coding agents' addresses) add lines but no attention.
+- **History:** a bare mirror of each repository, cloned and fetched with its organization's forge credential (passed to git through the environment, never in a URL or the mirror's config). Each tick reads at most `SLOP_METER_COMMITS_PER_TICK` commits of a history, oldest first, so a large history is read over several ticks; the loop comes back after `SLOP_METER_CATCHUP_SECONDS` while one is behind. Every git call has a timeout (`SLOP_METER_GIT_TIMEOUT_SECONDS`). These are the process's own limits, and stay variables.
+- **Forge events** (GitHub only): issue and pull request comments, review comments and reviews, from a cursor per listing. These are API calls, bounded per tick and credential (`slop_meter.api_calls_per_tick`) and stopped once the credential's remaining rate limit drops below `slop_meter.rate_reserve`, because jobs use the same credential. Git fetches are not API calls.
 
 ## What it keeps
 
 - **On disk:** one bare mirror per repository in scope, under `SLOP_METER_DATA_PATH` (`/data/embry0/slop-meter`, inside the orchestrator's data volume), one directory per segment of its name, lowercased: `acme/widgets` at `acme/widgets.git`, a GitLab project in a subgroup, `group/sub/project`, at `group/sub/project.git` (at most 21 segments, GitLab's deepest). git is started in the mirror's directory as the meter opened it, so a link swapped in before git starts is never followed; what git resolves for itself once it is running is git's, and the meter checks the way again after each clone and fetch ([the guard](ops/background-data.md)). A full mirror is the repository's whole history, so size the volume for it.
-- **In the database:** each repository's commits as read (author name and email, date, per-file line counts, co-author trailers), its forge events (login, kind, time), a map from forge logins to commit emails, the model's judgments of outlier commits, and the weekly series and current score per repository and area (the `slop_meter_*` tables, migrations 121 and 122). Contributor names, emails and logins are personal data: they are kept while the repository is in the meter's scope, replaced when its history is read again from the start, and removed with the rest of its rows and its mirror `background.prune_after_days` after it leaves, on the first tick past that (with the schedule off, at a start), unless it comes back first. A login goes once no remaining event refers to it. The removal never deletes anything outside `SLOP_METER_DATA_PATH` nor follows a link out of it ([what the background features keep](ops/background-data.md)).
+- **In the database:** each repository's commits as read (author name and email, date, per-file line counts, co-author trailers), its forge events (login, kind, time), a map from forge logins to commit emails, the model's judgments of outlier commits, and the weekly series and current score per repository and area, with the version of the settings each score was computed with (the `slop_meter_*` tables, migrations 121, 122 and 144). Contributor names, emails and logins are personal data: they are kept while the repository is in the meter's scope, replaced when its history is read again from the start, and removed with the rest of its rows and its mirror `background.prune_after_days` after it leaves, on the first tick past that (with the meter off, at its next run), unless it comes back first. A login goes once no remaining event refers to it. The removal never deletes anything outside `SLOP_METER_DATA_PATH` nor follows a link out of it ([what the background features keep](ops/background-data.md)).
 
 ## Where it shows
 
 - `GET /api/v1/repos/{repo}/-/slop-meter` and the repository page: the score, the level and a week-by-week line of cost, capacity and slop ([api.md](api.md)).
-- The Slop Dungeons in the [world](world.md) carry each area's reading; an area at Spaghetti Bolognese or worse has a dungeon even with no open slop finding.
+- The Slop Dungeons in the [world](world.md) carry each area's reading; an area at level 2 or worse has a dungeon even with no open slop finding.
 - Triage is told the job's area's (else the repository's) level, and the Slopmaster how much of the area landed beyond human attention.
 
 ## Not covered
diff --git a/embry0/api/app.py b/embry0/api/app.py
index 5565c3cf..73f54260 100644
--- a/embry0/api/app.py
+++ b/embry0/api/app.py
@@ -2671,9 +2671,10 @@ async def _lead_triggers() -> list[str]:
 
     # The Slop-O-Meter (spec 2026-10-26): each enrolled repository's history,
     # read a bounded batch a tick from a bare mirror fetched with its
-    # organization's credential, scored daily. Outliers are judged on
-    # background_models.slop_judge (#164). A repository that leaves its scope
-    # loses its mirror and its rows on the next tick (#165).
+    # organization's credential, scored every slop_meter.interval_hours with
+    # the slop_meter section as the repository reads it (#169). Outliers are
+    # judged on background_models.slop_judge (#164). A repository that leaves
+    # its scope loses its mirror and its rows on the next tick (#165).
     from pathlib import Path as _Path
 
     from fastapi import HTTPException
@@ -2684,7 +2685,7 @@ async def _lead_triggers() -> list[str]:
     from embry0.audit.helpers import emit_audit as _slop_meter_emit_audit
     from embry0.orchestration import dispatch_actors as _slop_meter_actors
     from embry0.services.background_scope import registered_reader, registry_reader
-    from embry0.services.slop_meter.loop import SlopMeterLoop, meter_reader, slop_meter_settings
+    from embry0.services.slop_meter.loop import SlopMeterLoop, meter_reader, slop_meter_limits
     from embry0.services.slop_meter.loop import repo_bots as slop_meter_repo_bots
     from embry0.services.slop_meter.mirror import GitMirror
     from embry0.services.slop_meter.prune import audit_writer as _slop_meter_audit_writer
@@ -2713,20 +2714,30 @@ async def _slop_meter_client(repo: str) -> Any:
         except HTTPException:
             return None
 
+    from types import SimpleNamespace as _SlopMeterOrg
+
+    async def _slop_meter_moved(section: str, owner: str, settings: Mapping[str, Any]) -> Mapping[str, Any]:
+        # An organization whose layer has not imported its slop_meter_bots yet (a first start whose copy
+        # failed) still reads them from its row, and its copy is tried again (#169).
+        view = await app.state.budget_policy.view([_SlopMeterOrg(owner=owner, settings=settings)])
+        moved: Mapping[str, Any] = view.moved_values(section, owner, settings)
+        return moved
+
     async def _slop_meter_bots(repo: str) -> list[str]:
         return await slop_meter_repo_bots(
             repo,
             prefs=app.state.repo_preferences_repo,
             orgs=app.state.organizations_repo,
             credentials=app.state.credentials_repo,
+            moved=_slop_meter_moved,
         )
 
     app.state.slop_meter = SlopMeterLoop(
         # The registered repositories, of which each tick reads the active ones enrolled in
         # background.slop_meter (#165), keeps what it read of every enrolled one, active or not, and
         # removes what it kept of the rest background.prune_after_days after they left (recorded in
-        # background_scope_exits, each removal audited); the enrollment and the judge's model
-        # (background_models.slop_judge) come from one snapshot a tick.
+        # background_scope_exits, each removal audited); the enrollment, the judge's model
+        # (background_models.slop_judge) and the slop_meter section come from one snapshot a tick.
         repos=registry_reader(app.state.repos_repo),
         read=meter_reader(app.state.settings),
         store=app.state.slop_meter_repo,
@@ -2739,7 +2750,7 @@ async def _slop_meter_bots(repo: str) -> list[str]:
         client_for=_slop_meter_client,
         bots=_slop_meter_bots,
         calls=app.state.background_calls,
-        settings=slop_meter_settings(config),
+        limits=slop_meter_limits(config),
     )
     slop_meter_task = asyncio.create_task(app.state.slop_meter.start())
     app.state.background_tasks.add(slop_meter_task)
diff --git a/embry0/api/v1/slop_meter.py b/embry0/api/v1/slop_meter.py
index 7b1d9c70..d4755eb5 100644
--- a/embry0/api/v1/slop_meter.py
+++ b/embry0/api/v1/slop_meter.py
@@ -1,8 +1,9 @@
 """The Slop-O-Meter's readings of a repository (spec 2026-10-26, slop-o-meter).
 
 ``GET /repos/{repo}/-/slop-meter``: the repository's score and level, each area's,
-where reading its history stands, and the week-by-week series of attention
-cost, capacity and slop for the repository or one area. After Slop-O-Meter's
+where reading its history stands (and the configuration version its score
+was computed with, #169), and the week-by-week series of attention cost,
+capacity and slop for the repository or one area. After Slop-O-Meter's
 published slop score algorithm (https://github.com/slop-o-meter/slop-o-meter).
 """
 
@@ -61,5 +62,7 @@ async def read_slop_meter(full_repo: str, request: Request, area: str = Query(de
             "commits_total": int(state.get("commits_total") or 0),
             "computed_at": _iso(state.get("computed_at")),
             "error": state.get("error"),
+            # The digest of the slop_meter settings the repository's score was computed from (#169).
+            "config_version": str((rows.get("") or {}).get("config_version") or "") or None,
         },
     }
diff --git a/embry0/config.py b/embry0/config.py
index b6eec630..42fa6183 100644
--- a/embry0/config.py
+++ b/embry0/config.py
@@ -855,20 +855,26 @@ def _gitlab_url_is_an_https_host(cls, v: str) -> str:
     # (#165). SLOP_METER_REPOS and SLOP_METER_EXCLUDE (comma-separated) are
     # only the import source of the repository layers' background.slop_meter,
     # read once at the first start of the release that added the section, and
-    # removed in the next release. Each one's bare mirror lives under the data
-    # path, removed with its rows background.prune_after_days after it leaves
-    # the scope (docs/ops/background-data.md). The loop runs every interval (0 is off),
-    # sooner while a history is still being read, and each tick reads at most
-    # these many commits, event pages, pull requests' reviews, logins and
-    # outlier judgments per repository. Its forge calls share one budget per
-    # tick and stop when the credential's remaining rate limit drops below the
-    # reserve (jobs use the same credential). Outliers are judged on
-    # background_models.slop_judge.
+    # removed in the next release.
     slop_meter_repos: Annotated[str, NOT_SECRET] = ""
     slop_meter_exclude: Annotated[str, NOT_SECRET] = ""
+    # How often it reads, whether it reads at all and its forge budget are the
+    # settings document's `slop_meter` section now (#169): interval_hours and
+    # enabled (SLOP_METER_INTERVAL_SECONDS=0 was off), api_calls_per_tick and
+    # rate_reserve, an organization's layer over the deployment's. These
+    # three are only its import source: read once, at the first start of the
+    # release that added the section, and ignored after that; removed in the
+    # next release.
     slop_meter_api_calls_per_tick: int = Field(default=200, ge=0)
     slop_meter_rate_reserve: int = Field(default=2_000, ge=0)
     slop_meter_interval_seconds: float = Field(default=86_400.0, ge=0)
+    # The process's own limits, which stay variables: each repository's bare
+    # mirror lives under the data path (a container path), removed with its
+    # rows background.prune_after_days after it leaves the scope
+    # (docs/ops/background-data.md); every git call has a timeout; while a
+    # history is still being read the loop comes back after the catch-up
+    # interval; and each tick reads at most these many commits, event pages,
+    # pull requests' reviews, logins and outlier judgments per repository.
     slop_meter_catchup_seconds: float = Field(default=300.0, gt=0)
     slop_meter_data_path: Annotated[str, NOT_SECRET] = "/data/embry0/slop-meter"
     slop_meter_git_timeout_seconds: float = Field(default=900.0, gt=0)
diff --git a/embry0/mcp_server/server.py b/embry0/mcp_server/server.py
index a7a96c54..67d79175 100644
--- a/embry0/mcp_server/server.py
+++ b/embry0/mcp_server/server.py
@@ -1064,8 +1064,10 @@ async def org_update(
     365 or null, context_audit_open_prs a boolean, the caps a number more than 0 and at most 50 and an
     integer 0 to 50, or null for the deployment's), and writes them into that layer; the answer's
     deprecated says so.
-    slop_meter_bots (list of up to 100 strings): the owner's own bots, as commit names, addresses
-    or forge logins, which the Slop-O-Meter counts as a bot's work, not a person's attention.
+    slop_meter_bots (list of up to 100 strings): deprecated. It is the organization's layer of the
+    settings document's slop_meter section now (bots): set it with
+    settings_set_keys(section="slop_meter", owner=...). Until 0.2.0 this tool still takes it and
+    writes it into that layer; the answer's deprecated says so.
     An unknown key, a wrong type or a value out of range is refused. Returns the organization. Needs
     an admin-scope key. Requires confirm=true (changes what embry0 does, and may spend, for every
     repository under the owner)."""
diff --git a/embry0/services/organizations.py b/embry0/services/organizations.py
index 1f904e25..bf8e1c2b 100644
--- a/embry0/services/organizations.py
+++ b/embry0/services/organizations.py
@@ -34,9 +34,10 @@
 # and context_audit_open_prs: moved into the settings document (MOVED_SETTINGS
 # below), the first into the `context_audit` section's days (ADR 0020), the
 # next two into the `budget` section's caps (ADR 0021), the last into
-# `context_audit`'s open_prs (ADR 0022). PATCH /orgs still takes them until
-# MOVED_SETTINGS_REMOVED_IN and writes them into the organization's layer;
-# nothing reads them here any more.
+# `context_audit`'s open_prs (ADR 0022). slop_meter_bots, the owner's own
+# bots (#184), moved into the `slop_meter` section's bots (#169). PATCH /orgs
+# still takes them until MOVED_SETTINGS_REMOVED_IN and writes them into the
+# organization's layer; nothing reads them here any more.
 SETTINGS: dict[str, type] = {
     "auto_register": bool,
     "rediscover_hours": int,
@@ -200,8 +201,27 @@ def context_audit_open_prs_moved(settings: Mapping[str, Any]) -> bool | None:
     return True if context_audit_open_prs(settings) else None
 
 
+def slop_meter_bots(settings: Mapping[str, Any]) -> list[str] | None:
+    """The owner's ``slop_meter_bots`` as the meter read them (#184): each string, stripped, blanks left out, and
+    each named once without regard to case (the first spelling kept), as matching ignored case; None for none.
+
+    A row written before ``POST /orgs`` checked its settings may hold anything
+    here, so a value that is no list reads as none, as it did.
+    """
+    value = settings.get("slop_meter_bots")
+    if not isinstance(value, list):
+        return None
+    seen: dict[str, str] = {}
+    for entry in value:
+        text = entry.strip() if isinstance(entry, str) else ""
+        if text:
+            seen.setdefault(text.lower(), text)
+    return list(seen.values()) or None
+
+
 #: The settings sections took over: an organization's own caps of its context audits, which the `budget`
-#: section took (#171), and whether and how its repositories are audited, which `context_audit` took (#170).
+#: section took (#171), whether and how its repositories are audited, which `context_audit` took (#170), and
+#: its own bots, which `slop_meter` took (#169).
 MOVED_SETTINGS: Final[tuple[MovedSetting, ...]] = (
     MovedSetting("context_audit_budget_usd", "budget", "context_audit_job_usd", context_audit_budget_usd),
     MovedSetting(
@@ -209,6 +229,7 @@ def context_audit_open_prs_moved(settings: Mapping[str, Any]) -> bool | None:
     ),
     MovedSetting("context_audit_days", "context_audit", "days", context_audit_days),
     MovedSetting("context_audit_open_prs", "context_audit", "open_prs", context_audit_open_prs_moved),
+    MovedSetting("slop_meter_bots", "slop_meter", "bots", slop_meter_bots),
 )
 MOVED: Final[dict[str, MovedSetting]] = {moved.legacy: moved for moved in MOVED_SETTINGS}
 
diff --git a/embry0/services/slop_meter/context.py b/embry0/services/slop_meter/context.py
index 3bac1182..16adea01 100644
--- a/embry0/services/slop_meter/context.py
+++ b/embry0/services/slop_meter/context.py
@@ -13,9 +13,6 @@
 
 logger = structlog.get_logger(__name__)
 
-#: The level at which triage leans toward slop on a borderline verdict (Sloppy Joe).
-LEAN_LEVEL = 4
-
 
 def meter_sentence(scope: str, row: Mapping[str, Any]) -> str:
     """One reading in plain words: the level, the score, and what the score means."""
diff --git a/embry0/services/slop_meter/globs.py b/embry0/services/slop_meter/globs.py
new file mode 100644
index 00000000..b3913455
--- /dev/null
+++ b/embry0/services/slop_meter/globs.py
@@ -0,0 +1,132 @@
+"""How the Slop-O-Meter's settings name files: globs, directory names and test marks (#169).
+
+A glob is matched against a changed file's path, without regard to case.
+One with no ``/`` is matched against the file's name, in any directory
+(``*.py``, ``test_?*.py``); one with a ``/`` against its whole path from the
+repository's root (``db/migrations/*.sql``, ``generated/**``). ``*`` matches
+any characters within one name, ``?`` one character, and ``**`` stands
+alone between slashes for any number of directories: at the start or in the
+middle none included, at the end every file below. A glob holds lowercase
+letters, digits, ``.``, ``_``, ``-``, ``+``, ``@``, ``~``, ``*``, ``?`` and
+``/``: matching ignores case, so a capital would only be a second spelling
+of the same glob.
+
+A directory name is one name matched at any depth, and a test mark one word
+of a file's name (:func:`marked`). Every check raises :class:`ValueError`
+with a message that never repeats the text it checked.
+
+This module imports nothing of embry0, so a settings section may import it.
+"""
+
+from __future__ import annotations
+
+import functools
+import re
+from typing import Final
+
+MAX_GLOB_LENGTH: Final = 200
+MAX_DIR_LENGTH: Final = 100
+MAX_MARK_LENGTH: Final = 50
+
+_GLOB_CHARACTERS: Final = re.compile(r"[a-z0-9._+@~*?/-]+\Z")
+_DIR_CHARACTERS: Final = re.compile(r"[a-z0-9._+@~-]+\Z")
+_MARK_CHARACTERS: Final = re.compile(r"[a-z0-9_+~-]+\Z")
+
+
+def check_glob(glob: str) -> str:
+    """``glob`` when it is one this module matches as the module docstring says; else :class:`ValueError`."""
+    if not glob:
+        raise ValueError("write a glob, such as *.py or db/migrations/*.sql")
+    if len(glob) > MAX_GLOB_LENGTH:
+        raise ValueError(f"a glob is at most {MAX_GLOB_LENGTH} characters")
+    if not _GLOB_CHARACTERS.match(glob):
+        raise ValueError(
+            "a glob holds only lowercase letters, digits, '.', '_', '-', '+', '@', '~', '*', '?' and '/' "
+            "(matching ignores case)"
+        )
+    segments = glob.split("/")
+    if not all(segments):
+        raise ValueError("a glob with a '/' starts at the repository's root: no leading, trailing or doubled '/'")
+    if any(segment in (".", "..") for segment in segments):
+        raise ValueError("a glob names no '.' or '..' directory")
+    if any("**" in segment and segment != "**" for segment in segments):
+        raise ValueError("'**' stands alone between slashes, as in generated/** or src/**/*.pb.go")
+    if len(segments) == 1 and segments[0] == "**":
+        raise ValueError("'**' alone matches every file: write a directory before it, as in generated/**")
+    if any(a == b == "**" for a, b in zip(segments, segments[1:], strict=False)):
+        raise ValueError("write '**' once in a row: **/**/ matches what **/ does")
+    return glob
+
+
+def check_dir_name(name: str) -> str:
+    """``name`` when it is one directory name; else :class:`ValueError`."""
+    if not name:
+        raise ValueError("write a directory name, such as vendor")
+    if len(name) > MAX_DIR_LENGTH:
+        raise ValueError(f"a directory name is at most {MAX_DIR_LENGTH} characters")
+    if not _DIR_CHARACTERS.match(name) or name in (".", ".."):
+        raise ValueError(
+            "a directory is one name of lowercase letters, digits, '.', '_', '-', '+', '@' and '~', such as "
+            "node_modules: no '/', no wildcard, not '.' or '..' (matching ignores case)"
+        )
+    return name
+
+
+def check_mark(mark: str) -> str:
+    """``mark`` when it is one word a test file's name may carry before its extension; else :class:`ValueError`."""
+    if not mark:
+        raise ValueError("write a word, such as test")
+    if len(mark) > MAX_MARK_LENGTH:
+        raise ValueError(f"a mark is at most {MAX_MARK_LENGTH} characters")
+    if not _MARK_CHARACTERS.match(mark):
+        raise ValueError(
+            "a mark is one word of lowercase letters, digits, '_', '-', '+' and '~', such as spec: no '.', no "
+            "wildcard (matching ignores case)"
+        )
+    return mark
+
+
+def _segment(text: str) -> str:
+    out = []
+    for char in text:
+        if char == "*":
+            out.append("[^/]*")
+        elif char == "?":
+            out.append("[^/]")
+        else:
+            out.append(re.escape(char))
+    return "".join(out)
+
+
+@functools.lru_cache(maxsize=4096)
+def compile_glob(glob: str) -> re.Pattern[str]:
+    """``glob`` as a regular expression over a lowercased name (no ``/`` in it) or path (one)."""
+    lowered = glob.lower()
+    if "/" not in lowered:
+        return re.compile(_segment(lowered) + r"\Z")
+    segments = lowered.split("/")
+    out = []
+    for position, segment in enumerate(segments):
+        last = position == len(segments) - 1
+        if segment == "**":
+            out.append(".+" if last else "(?:[^/]+/)*")
+        else:
+            out.append(_segment(segment) + ("" if last else "/"))
+    return re.compile("".join(out) + r"\Z")
+
+
+def matches(glob: str, path: str) -> bool:
+    """Whether ``glob`` matches ``path``, a file's path from the repository's root, lowercased."""
+    target = path if "/" in glob else path.rsplit("/", 1)[-1]
+    return compile_glob(glob).fullmatch(target) is not None
+
+
+def marked(name: str, marks: frozenset[str]) -> bool:
+    """Whether a lowercased file ``name`` carries one of ``marks`` just before its extension: ``a.test.ts``,
+    ``b.spec.js``. A name with no extension carries none, and nor does ``a.test.helper.ts``: the word must be
+    the last part of the name before its extension."""
+    stem, dot, extension = name.rpartition(".")
+    if not dot or not extension:
+        return False
+    word = stem.rpartition(".")[2]
+    return bool(stem) and "." in stem and word in marks
diff --git a/embry0/services/slop_meter/history.py b/embry0/services/slop_meter/history.py
index cfcb950d..585b2683 100644
--- a/embry0/services/slop_meter/history.py
+++ b/embry0/services/slop_meter/history.py
@@ -73,14 +73,17 @@
 _BULLET = re.compile(r"^[ \t]*[*-][ \t]+\S", re.M)
 
 
-def is_bot(name: str, email: str, bots: frozenset[str] | None = None) -> bool:
+def is_bot(name: str, email: str, bots: frozenset[str] | None = None, agents: Iterable[str] = ()) -> bool:
     """A bot or an AI coding agent: a known name, a ``[bot]`` name or address, ``noreply@``, an agent's address,
-    or a name, address or login in ``bots`` (:func:`own_identities`; embry0's own when none is given)."""
+    a name, address or login in ``bots`` (:func:`own_identities`; embry0's own when none is given), or an
+    address that starts with one of ``agents`` (the ``slop_meter`` section's ``ai_agents``, lowercased)."""
     name, email = name.strip().lower(), email.strip().lower()
     if name in KNOWN_BOTS or name.endswith("[bot]"):
         return True
     if email.endswith("[bot]@users.noreply.github.com") or email.startswith(("noreply@", *_AI_EMAIL_PREFIXES)):
         return True
+    if email and any(email.startswith(prefix) for prefix in agents):
+        return True
     own = _embry0_identities() if bots is None else bots
     return name in own or email in own
 
@@ -108,14 +111,20 @@ def _embry0_identities() -> frozenset[str]:
     return own_identities()
 
 
-def with_bots(commits: Sequence[Commit], bots: frozenset[str]) -> list[Commit]:
-    """``commits`` as they read with ``bots`` known: a listed author's commit is a bot's, and a listed
-    co-author co-wrote as an agent does, not as a person. Rows read before an identity was listed are
-    corrected here, when scored, without reading the history again."""
+def agent_prefixes(agents: Iterable[str]) -> tuple[str, ...]:
+    """The ``slop_meter`` section's ``ai_agents`` as :func:`is_bot` matches them: lowercased, blanks dropped."""
+    return tuple(dict.fromkeys(a.strip().lower() for a in agents if a.strip()))
+
+
+def with_bots(commits: Sequence[Commit], bots: frozenset[str], agents: Iterable[str] = ()) -> list[Commit]:
+    """``commits`` as they read with ``bots`` and the AI agents' address prefixes ``agents`` known: a listed
+    author's commit is a bot's, and a listed co-author co-wrote as an agent does, not as a person. Rows read
+    before an identity was listed are corrected here, when scored, without reading the history again."""
+    prefixes = agent_prefixes(agents)
     out: list[Commit] = []
     for c in commits:
-        bot = c.bot or is_bot(c.author_name, c.author_email, bots)
-        humans = tuple(co for co in c.coauthors if not is_bot(co[0], co[1], bots))
+        bot = c.bot or is_bot(c.author_name, c.author_email, bots, prefixes)
+        humans = tuple(co for co in c.coauthors if not is_bot(co[0], co[1], bots, prefixes))
         ai = c.ai_coauthor or len(humans) != len(c.coauthors)
         unchanged = (bot, humans, ai) == (c.bot, c.coauthors, c.ai_coauthor)
         out.append(c if unchanged else replace(c, bot=bot, coauthors=humans, ai_coauthor=ai))
diff --git a/embry0/services/slop_meter/judge.py b/embry0/services/slop_meter/judge.py
index 265f9fc3..7647d675 100644
--- a/embry0/services/slop_meter/judge.py
+++ b/embry0/services/slop_meter/judge.py
@@ -4,7 +4,9 @@
 one, on ``background_models.slop_judge`` through the background call every
 brief makes (``embry0.services.background_models``): slop, or not slop
 with a reason (a code drop, a restructuring, a vendored import). A judgment is
-kept per commit and never asked again.
+kept per commit and never asked again. What the model is told slop is, is the
+settings document's ``slop_meter.judge_prompt`` (#169); the form of its answer
+is this module's, said after the guidance, as :func:`parse_judgment` reads it.
 """
 
 from __future__ import annotations
@@ -16,19 +18,19 @@
 
 from embry0.services.background_models import BackgroundCalls, Endpoint
 from embry0.services.slop_meter.score import Outlier
+from embry0.settings.sections.slop_meter import DEFAULT_JUDGE_PROMPT
 
 #: The key of ``background_models`` the judge runs on, and what its spend is recorded under.
 FEATURE = "slop_judge"
 
-SYSTEM_PROMPT = """\
-You judge one large commit of a software repository: did it add bulk code no
-person wrote or reviewed line by line (slop, such as a large AI-generated
-change), or is its size explained by something else (not slop: the project's
-initial import, a code drop moved in from elsewhere, a restructuring that moved
-files, a vendored or generated library, a data or fixture dump)?
-Judge from what the message and the files say. When it is unclear, answer
-slop: false only if the files themselves look moved, vendored or generated.
-Answer with JSON: {"slop": true|false, "reason": "<one plain sentence>"}."""
+#: The form of the answer, said after the guidance: what :func:`parse_judgment` reads.
+ANSWER_FORM = """Answer with JSON: {"slop": true|false, "reason": "<one plain sentence>"}."""
+
+
+def system_prompt(guidance: str = DEFAULT_JUDGE_PROMPT) -> str:
+    """What the judge is told: ``guidance`` (``slop_meter.judge_prompt``), then the form of its answer."""
+    return f"{guidance.rstrip()}\n{ANSWER_FORM}"
+
 
 SCHEMA: dict[str, Any] = {
     "type": "object",
@@ -66,16 +68,23 @@ def parse_judgment(text: str) -> tuple[bool, str]:
 
 
 async def judge(
-    repo: str, outlier: Outlier, endpoint: Endpoint, client: httpx.AsyncClient, calls: BackgroundCalls
+    repo: str,
+    outlier: Outlier,
+    endpoint: Endpoint,
+    client: httpx.AsyncClient,
+    calls: BackgroundCalls,
+    *,
+    guidance: str = DEFAULT_JUDGE_PROMPT,
 ) -> tuple[bool, str]:
     """``(slop, reason)``; ``ValueError`` for an answer that is not one, ``httpx.HTTPError`` for a failed call,
-    ``BackgroundCallRefused`` when the budget caps refuse it."""
+    ``BackgroundCallRefused`` when the budget caps refuse it. ``guidance`` is the repository's
+    ``slop_meter.judge_prompt``."""
     answer = await calls.ask(
         FEATURE,
         endpoint,
         client,
         repo=repo,
-        system=SYSTEM_PROMPT,
+        system=system_prompt(guidance),
         user=user_prompt(repo, outlier),
         schema=SCHEMA,
         name="judgment",
diff --git a/embry0/services/slop_meter/loop.py b/embry0/services/slop_meter/loop.py
index 1c27f901..5e057c1e 100644
--- a/embry0/services/slop_meter/loop.py
+++ b/embry0/services/slop_meter/loop.py
@@ -1,23 +1,30 @@
 """The Slop-O-Meter's background loop (spec 2026-10-26, slop-o-meter).
 
-Once a day (``SLOP_METER_INTERVAL_SECONDS``; 0 is off), for every repository
-in the meter's scope: registered, active and enrolled in ``background.slop_meter``
-of the settings document, through its organization's layer and its own
+Every ``slop_meter.interval_hours`` of the settings document (a day by
+default; ``slop_meter.enabled: false`` stops the reading), for every
+repository in the meter's scope: registered, active and enrolled in
+``background.slop_meter``, through its organization's layer and its own
 (:mod:`embry0.services.background_scope`, #165). First, once that enrollment
 is settled, what the meter keeps of any repository that left its scope is
 removed, ``background.prune_after_days`` after it left
 (:mod:`embry0.services.slop_meter.prune`); an inactive repository is not read
-and keeps what was read. Then, for each repository
-in scope: fetch its bare mirror, read the next batch of its history, read its
-forge events from their cursors and map a few logins (forge calls dealt
-round-robin from a shared per-tick budget, stopping at the credential's
-rate-limit reserve), judge a few outlier commits, and, once it is caught up,
-recompute its weekly series and its scores (repository and areas) off the
-event loop. Every step is bounded and resumes where the last tick stopped;
-while a repository has a backlog the loop comes back sooner
-(``SLOP_METER_CATCHUP_SECONDS``). A tick reads its enrollment and its judge's
-model from one snapshot of the settings documents (:func:`meter_reader`), so a
-change to either applies on the next tick with no restart.
+and keeps what was read. Then, for each repository in scope: fetch its bare
+mirror, read the next batch of its history, read its forge events from their
+cursors and map a few logins (forge calls dealt round-robin from a per-tick
+budget for each credential, stopping at its rate-limit reserve), judge a few
+outlier commits, and, once it is caught up, recompute its weekly series and
+its scores (repository and areas) off the event loop. Every step is bounded
+and resumes where the last tick stopped; while a repository has a backlog the
+loop comes back sooner (``SLOP_METER_CATCHUP_SECONDS``).
+
+A tick reads its enrollment, its judge's model and the ``slop_meter``
+section from one snapshot of the settings documents (:func:`meter_reader`),
+and scores each repository with the section as that repository reads it
+(#169). Each score records the section's :func:`config_version` for it. The
+schedule looks at the settings every :data:`LOOK_SECONDS`, so turning the
+meter on or off, or a new interval, applies within them, and a change to what
+a repository's score is computed from runs the next tick at once instead of
+at its next interval: the change rescores on the next run.
 """
 
 from __future__ import annotations
@@ -25,8 +32,8 @@
 import asyncio
 import hashlib
 from collections.abc import Awaitable, Callable, Iterable, Mapping
-from dataclasses import dataclass
-from datetime import UTC, datetime
+from dataclasses import dataclass, field
+from datetime import UTC, datetime, timedelta
 from typing import Any, Final
 
 import httpx
@@ -39,6 +46,7 @@
 from embry0.services.slop_meter.history import (
     HISTORY_VERSION,
     Commit,
+    agent_prefixes,
     is_bot,
     login_of_email,
     own_identities,
@@ -47,37 +55,43 @@
 )
 from embry0.services.slop_meter.judge import FEATURE
 from embry0.services.slop_meter.prune import Audit, PruneOutcome, Pruner
-from embry0.services.slop_meter.score import Event, Meter, meters, outliers
-from embry0.services.slop_meter.weights import CONFIG_FILES, Weigher, ignore_patterns, outlier_files
+from embry0.services.slop_meter.score import DEFAULTS, Event, Meter, meters, outliers
+from embry0.services.slop_meter.weights import CONFIG_FILES, FileRules, Weigher, ignore_patterns, outlier_files
+from embry0.settings.layers import PerRepository
+from embry0.settings.sections.slop_meter import SLOP_METER, SlopMeterSettings, config_version
 
 logger = structlog.get_logger(__name__)
 
+#: The longest the schedule waits between two looks at the settings: how soon turning the meter on or off, a
+#: new interval, or a change to what a score is computed from applies.
+LOOK_SECONDS: Final = 300.0
+
 
 @dataclass(frozen=True)
-class SlopMeterSettings:
-    interval_seconds: float = 86_400.0
+class SlopMeterLimits:
+    """What one tick may do per repository, and how soon it comes back while a history is behind.
+
+    The process's own limits, from the environment (``SLOP_METER_*``): they
+    bound the work and the memory of one tick. What the meter reads and how
+    it scores are the ``slop_meter`` section of the settings document.
+    """
+
     catchup_seconds: float = 300.0
     commits_per_tick: int = 5_000
     event_pages: int = 10
     reviews_per_tick: int = 50
     logins_per_tick: int = 20
     judgments_per_tick: int = 5
-    #: Forge API calls one tick may make across every repository, and the rate limit it leaves for jobs.
-    api_calls_per_tick: int = 200
-    rate_reserve: int = 2_000
 
 
-def slop_meter_settings(config: Any) -> SlopMeterSettings:
-    return SlopMeterSettings(
-        interval_seconds=float(getattr(config, "slop_meter_interval_seconds", 86_400)),
+def slop_meter_limits(config: Any) -> SlopMeterLimits:
+    return SlopMeterLimits(
         catchup_seconds=float(getattr(config, "slop_meter_catchup_seconds", 300)),
         commits_per_tick=int(getattr(config, "slop_meter_commits_per_tick", 5_000)),
         event_pages=int(getattr(config, "slop_meter_event_pages", 10)),
         reviews_per_tick=int(getattr(config, "slop_meter_reviews_per_tick", 50)),
         logins_per_tick=int(getattr(config, "slop_meter_logins_per_tick", 20)),
         judgments_per_tick=int(getattr(config, "slop_meter_judgments_per_tick", 5)),
-        api_calls_per_tick=int(getattr(config, "slop_meter_api_calls_per_tick", 200)),
-        rate_reserve=int(getattr(config, "slop_meter_rate_reserve", 2_000)),
     )
 
 
@@ -85,6 +99,16 @@ def slop_meter_settings(config: Any) -> SlopMeterSettings:
 SCOPE: Final = "slop_meter"
 
 
+class _Defaults:
+    """The ``slop_meter`` section with nothing written, for every repository: a read that names no snapshot."""
+
+    def deployment(self) -> SlopMeterSettings:
+        return DEFAULTS
+
+    def repo(self, repo: str | None) -> SlopMeterSettings:
+        return DEFAULTS
+
+
 @dataclass(frozen=True)
 class MeterRead:
     """What one tick of the meter reads, all from one snapshot of the settings documents."""
@@ -93,39 +117,52 @@ class MeterRead:
     models: ModelLookup
     #: Which repositories it reads (``background.slop_meter``), and whether that is settled.
     enrollment: Enrollment
+    #: The ``slop_meter`` section: the deployment's values (whether and how often it reads), and each
+    #: repository's (its organization's layer and its own over the deployment's).
+    meter: PerRepository[SlopMeterSettings] = field(default_factory=_Defaults)
 
 
 def meter_reader(store: Any) -> Callable[[], Awaitable[MeterRead]]:
     """The reader the meter is built with: each call takes one snapshot of the settings documents
-    (``store.snapshot()``) and reads both the judge's model and the enrollment from it."""
+    (``store.snapshot()``) and reads the judge's model, the enrollment and the ``slop_meter`` section from it."""
 
     async def read() -> MeterRead:
         snapshot = await store.snapshot()
-        return MeterRead(models=model_lookup(snapshot, "slop_judge"), enrollment=enrollment(snapshot))
+        return MeterRead(
+            models=model_lookup(snapshot, "slop_judge"),
+            enrollment=enrollment(snapshot),
+            meter=snapshot.scoped(SLOP_METER),
+        )
 
     return read
 
 
 @dataclass(frozen=True)
 class Inputs:
-    """What a repository's score is computed from: its history and its head's config files."""
+    """What a repository's score is computed from: its history, its head's config files, and its settings."""
 
     commits: list[Commit]
     events: list[Event]
     logins: dict[str, str]
     judgments: dict[str, bool]
     files: dict[str, str | None]
+    #: The ``slop_meter`` section as the repository reads it.
+    settings: SlopMeterSettings = DEFAULTS
 
 
-def weigher_for(commits: Iterable[Commit], files: Mapping[str, str | None]) -> Weigher:
-    """The repository's line weights: its type weights, its linters' ignore lists, and its outlier files."""
-    base = Weigher(ignore_patterns(files))
+def weigher_for(
+    commits: Iterable[Commit], files: Mapping[str, str | None], settings: SlopMeterSettings = DEFAULTS
+) -> Weigher:
+    """The repository's line weights: its ``slop_meter`` file rules, its linters' ignore lists, and its
+    outlier files."""
+    rules = FileRules.of(settings)
+    base = Weigher(ignore_patterns(files), rules=rules)
     sizes: dict[str, int] = {}
     for c in commits:
         for path, a, d in c.files:
             if base(path):
                 sizes[path] = sizes.get(path, 0) + a - d
-    return Weigher(ignore_patterns(files), outlier_files({p: s for p, s in sizes.items() if s > 0}))
+    return Weigher(ignore_patterns(files), outlier_files({p: s for p, s in sizes.items() if s > 0}), rules=rules)
 
 
 def logins_from(commits: Iterable[Commit], looked_up: Mapping[str, str]) -> dict[str, str]:
@@ -143,8 +180,9 @@ def logins_from(commits: Iterable[Commit], looked_up: Mapping[str, str]) -> dict
 
 
 def compute(inputs: Inputs) -> dict[str, Meter]:
-    """The repository's meter (``""``) and its areas', from the history as read. Pure: runs in a thread."""
-    weigh = weigher_for(inputs.commits, inputs.files)
+    """The repository's meter (``""``) and its areas', from the history as read, scored with ``inputs.settings``.
+    Pure: runs in a thread."""
+    weigh = weigher_for(inputs.commits, inputs.files, inputs.settings)
     areas = parse_areas(inputs.files.get(AREAS_PATH))
 
     def area_of(path: str) -> str | None:
@@ -152,7 +190,9 @@ def area_of(path: str) -> str | None:
         return found.name if found is not None else None
 
     logins = logins_from(inputs.commits, inputs.logins)
-    return meters(inputs.commits, inputs.events, logins, weigh, inputs.judgments, area_of=area_of)
+    return meters(
+        inputs.commits, inputs.events, logins, weigh, inputs.judgments, area_of=area_of, settings=inputs.settings
+    )
 
 
 TokenFor = Callable[[str], Awaitable[tuple[str, str, str] | None]]
@@ -170,12 +210,21 @@ class _Work:
     credential: str = ""
 
 
-async def repo_bots(repo: str, *, prefs: Any, orgs: Any, credentials: Any) -> list[str]:
-    """The identities a repository's readings count as bots beyond embry0's default one (#184).
+#: Reads what an organization's own settings still say of a moved key, until its layer has imported it
+#: (``BudgetView.moved_values``): ``(section, owner, settings) -> {key: value}``.
+MovedReader = Callable[[str, str, Mapping[str, Any]], Awaitable[Mapping[str, Any]]]
 
-    The addresses embry0 commits under there (the repository's preferred author,
-    the owner's credential's author) and the bots the owner lists in its
-    ``slop_meter_bots`` setting.
+
+async def repo_bots(
+    repo: str, *, prefs: Any, orgs: Any, credentials: Any, moved: MovedReader | None = None
+) -> list[str]:
+    """The identities a repository's readings count as bots beyond embry0's default one and the
+    ``slop_meter.bots`` its layers list (#184).
+
+    The addresses embry0 commits under there (the repository's preferred
+    author, the owner's credential's author), and, until the organization's
+    layer has imported it, the ``slop_meter_bots`` its own settings still
+    list (``moved``; :data:`embry0.services.organizations.MOVED_SETTINGS`).
     """
     out: list[str] = []
     pref = await prefs.get(repo)
@@ -187,9 +236,10 @@ async def repo_bots(repo: str, *, prefs: Any, orgs: Any, credentials: Any) -> li
             cred = await credentials.get(org.credential_id)
             if cred and cred.get("git_author_email"):
                 out.append(str(cred["git_author_email"]))
-        listed = org.settings.get("slop_meter_bots")
-        if isinstance(listed, list):
-            out.extend(str(v) for v in listed)
+        if moved is not None:
+            listed = (await moved(SLOP_METER.name, org.owner, org.settings)).get("bots")
+            if isinstance(listed, list | tuple):
+                out.extend(str(v) for v in listed)
     return out
 
 
@@ -199,17 +249,20 @@ class SlopMeterLoop:
     ``repos()`` lists the registered repositories, active or not
     (:func:`embry0.services.background_scope.registry_reader`): the tick reads
     the active ones enrolled in the meter, and keeps what it read of every
-    enrolled one. ``read()``, once a tick, the enrollment and the model each
+    enrolled one. ``read()``, once a tick, the enrollment, the model each
     repository's outliers are judged on ('' for none:
-    ``background_models.slop_judge``, else its default), from one snapshot
-    (:func:`meter_reader`); ``token_for(repo)`` the forge, credential and
+    ``background_models.slop_judge``, else its default) and the
+    ``slop_meter`` section, from one snapshot (:func:`meter_reader`);
+    ``token_for(repo)`` the forge, credential and
     GitLab URL to fetch with (None when there is none), ``client_for(repo)``
     the GitHub client to read events with (None for a GitLab repository), and
     ``calls`` makes each judgment's call with the repository's key, the
     budget caps and the spend recorded (#164). ``mirror``, ``store``,
     ``exits`` and ``audit`` remove what the meter keeps of a repository that
     left its scope, after ``background.prune_after_days``
-    (:class:`embry0.services.slop_meter.prune.Pruner`).
+    (:class:`embry0.services.slop_meter.prune.Pruner`). ``limits`` are the
+    process's (:class:`SlopMeterLimits`), and ``sleep`` how the schedule
+    waits (:meth:`start`).
     """
 
     def __init__(
@@ -225,9 +278,10 @@ def __init__(
         client_for: ClientFor,
         bots: Callable[[str], Awaitable[Iterable[str]]],
         calls: BackgroundCalls,
-        settings: SlopMeterSettings,
+        limits: SlopMeterLimits,
         clock: Callable[[], datetime] = lambda: datetime.now(UTC),
         http: httpx.AsyncClient | None = None,
+        sleep: Callable[[float], Awaitable[Any]] = asyncio.sleep,
     ) -> None:
         self._repos = repos
         self._read = read
@@ -236,37 +290,60 @@ def __init__(
         self._pruner = Pruner(store=store, mirror=mirror, exits=exits, audit=audit, clock=clock)
         self._token_for = token_for
         self._client_for = client_for
-        #: The tick's ``repo -> model``, read at its start.
+        #: The tick's ``repo -> model`` and ``slop_meter`` section, read at its start.
         self._lookup: ModelLookup | None = None
+        self._meter: PerRepository[SlopMeterSettings] = _Defaults()
         #: A repository's own bots and embry0's commit identities for it (#184).
         self._bots = bots
         self._calls = calls
-        self._settings = settings
+        self._limits = limits
         self._clock = clock
         self._http = http
+        self._sleep = sleep
         self._turn = 0
-
-    async def tick(self) -> bool:
-        """One pass over the repositories in scope; True when one still has a backlog.
+        #: When the last run of the schedule ended; None before the first.
+        self._last_pass: datetime | None = None
+        #: When the next run falls due, as the last look read the section.
+        self._due: datetime | None = None
+        #: Whether the last run left a repository with a backlog: the next comes ``catchup_seconds`` later.
+        self._backlog = False
+        #: Whether the last look found the meter on; None before the first.
+        self._enabled: bool | None = None
+        #: Each repository the last run read, with the configuration version it read it with: a look that finds
+        #: one of them reading another version runs the next tick at once.
+        self._versions: dict[str, str] = {}
+
+    @property
+    def last_pass(self) -> datetime | None:
+        """When the schedule's last run ended, a reading or a removal only; None before its first."""
+        return self._last_pass
+
+    async def tick(self, read: MeterRead | None = None) -> bool:
+        """One pass over the repositories in scope, whether the meter is on or off; True when one still has a
+        backlog. ``read`` is what the schedule's look read (else it is read now).
 
         The settings and the registry are read first: which repositories are
-        enrolled, and the judge's model, from one snapshot. What the meter
-        keeps under a spelling the registry spells otherwise moves onto the
-        registry's. Once the enrollment is settled, what it keeps of a
-        repository out of scope is removed after the grace period. Then the
-        git work (no API calls). Then the forge calls, dealt one per
-        repository in turn from a budget shared by all of them, so a large
+        enrolled, the judge's model and the ``slop_meter`` section, from one
+        snapshot. What the meter keeps under a spelling the registry spells
+        otherwise moves onto the registry's. Once the enrollment is settled,
+        what it keeps of a repository out of scope is removed after the grace
+        period. Then the git work (no API calls). Then the forge calls, dealt
+        one per repository in turn from its credential's budget, so a large
         backlog in one cannot starve the rest; the starting repository
-        rotates every tick. Last, every repository that is caught up is scored.
+        rotates every tick. Last, every repository that is caught up is
+        scored with the section as it reads it, recording its version.
         """
-        read = await self._read()
+        if read is None:
+            read = await self._read()
         registered = await self._repos()
         await self._respell(registered.every)
         await self._prune(read, registered)
         names = read.enrollment.scope(SCOPE, registered.active)
+        self._versions = {repo: config_version(read.meter.repo(repo)) for repo in names}
         if not names:
             return False
         self._lookup = read.models
+        self._meter = read.meter
         turn = self._turn % len(names)
         self._turn += 1
         order = names[turn:] + names[:turn]
@@ -318,9 +395,10 @@ async def _prune(self, read: MeterRead, registered: Registered) -> PruneOutcome
             logger.warning("slop_meter_prune_failed", exc_info=True)
             return None
 
-    async def prune_only(self) -> PruneOutcome | None:
-        """What a tick removes, and nothing else."""
-        read = await self._read()
+    async def prune_only(self, read: MeterRead | None = None) -> PruneOutcome | None:
+        """What a tick removes, and nothing else: the run of a schedule with the meter off."""
+        if read is None:
+            read = await self._read()
         registered = await self._repos()
         await self._respell(registered.every)
         return await self._prune(read, registered)
@@ -352,7 +430,7 @@ async def _read_history(self, repo: str) -> _Work:
                 await self._store.forget_history(repo)
                 done = 0
             await self._store.set_state(repo, history_version=HISTORY_VERSION)
-        batch = history[done : done + self._settings.commits_per_tick]
+        batch = history[done : done + self._limits.commits_per_tick]
         if batch:
             commits = parse_log(await self._mirror.log(repo, batch))
             await self._store.add_commits(repo, done, [c.to_row() for c in commits])
@@ -365,7 +443,7 @@ async def _reader(self, repo: str) -> EventReader | None:
         client = await self._client_for(repo)
         if client is None:
             return None
-        s = self._settings
+        s = self._limits
         state = await self._store.state(repo)
         known = set(await self._store.logins())
         known |= {login for email in await self._store.authors(repo) if (login := login_of_email(email))}
@@ -386,12 +464,15 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
         """Every GitHub repository's events, one API call per repository in turn.
 
         Repositories read with one credential share its budget for the tick:
-        ``api_calls_per_tick`` calls, stopping at its rate limit's reserve. One
-        credential running low never stops a repository read with another (#185).
+        ``slop_meter.api_calls_per_tick`` calls, stopping at its rate limit's
+        ``rate_reserve``, each as the repository's organization reads them;
+        where organizations that read with one credential set different
+        values, the fewest calls and the largest reserve apply, since the rate
+        limit is the credential's. One credential running low never stops a
+        repository read with another (#185).
         """
-        s = self._settings
-        budgets: dict[str, ApiBudget] = {}
         readers: dict[str, EventReader] = {}
+        bounds: dict[str, tuple[int, int]] = {}
         for repo in order:
             if repo in work and work[repo].forge == "github":
                 try:
@@ -401,7 +482,13 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                     continue
                 if reader is not None:
                     readers[repo] = reader
-                    budgets.setdefault(work[repo].credential, ApiBudget(s.api_calls_per_tick, s.rate_reserve))
+                    own = self._meter.repo(repo)
+                    calls, reserve = bounds.get(work[repo].credential, (own.api_calls_per_tick, own.rate_reserve))
+                    bounds[work[repo].credential] = (
+                        min(calls, own.api_calls_per_tick),
+                        max(reserve, own.rate_reserve),
+                    )
+        budgets = {credential: ApiBudget(calls, reserve) for credential, (calls, reserve) in bounds.items()}
         active = list(readers)
         waiting: list[str] = []
         while active:
@@ -425,7 +512,7 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                 "slop_meter_api_budget_spent",
                 calls=[b.made for b in spent],
                 remaining=[b.remaining for b in spent],
-                reserve=s.rate_reserve,
+                reserve=[b.reserve for b in spent],
                 waiting=sorted(waiting),
             )
         for repo, reader in readers.items():
@@ -442,33 +529,43 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
             if repo in waiting:
                 work[repo].more = True
 
-    async def _inputs(self, repo: str) -> Inputs:
-        bots = own_identities(await self._bots(repo))
-        commits = with_bots([Commit.from_row(r) for r in await self._store.commits(repo)], bots)
+    async def _inputs(self, repo: str, settings: SlopMeterSettings) -> Inputs:
+        bots = own_identities([*await self._bots(repo), *settings.bots])
+        agents = agent_prefixes(settings.ai_agents)
+        commits = with_bots([Commit.from_row(r) for r in await self._store.commits(repo)], bots, agents)
         events = [
             Event(str(e["login"]), e["at"], str(e["kind"]))
             for e in await self._store.events(repo)
-            if not is_bot(str(e["login"]), "", bots)
+            if not is_bot(str(e["login"]), "", bots, agents)
         ]
         files = {name: await self._mirror.read(repo, name) for name in (*CONFIG_FILES, AREAS_PATH)}
-        return Inputs(commits, events, await self._store.logins(), await self._store.judgments(repo), files)
+        return Inputs(commits, events, await self._store.logins(), await self._store.judgments(repo), files, settings)
 
     async def _score(self, repo: str) -> None:
-        inputs = await self._inputs(repo)
+        """Score ``repo`` with the ``slop_meter`` section as it reads it, recording that section's version."""
+        settings = self._meter.repo(repo)
+        version = config_version(settings)
+        inputs = await self._inputs(repo, settings)
         await self._judge(repo, inputs)
         results = await asyncio.to_thread(compute, inputs)
         now = self._clock()
-        await self._store.store(repo, results, now)
+        await self._store.store(repo, results, now, config_version=version)
         await self._store.set_state(repo, computed_at=now, error=None, error_at=None)
         top = results[""]
         logger.info(
-            "slop_meter_scored", repo=repo, score=round(top.score, 4), level=top.name, provisional=top.provisional
+            "slop_meter_scored",
+            repo=repo,
+            score=round(top.score, 4),
+            level=top.name,
+            provisional=top.provisional,
+            config_version=version,
         )
 
     async def _judge(self, repo: str, inputs: Inputs) -> None:
         """Ask the model about a few outlier commits not judged yet; what it answers is kept on ``inputs``."""
-        weigh = weigher_for(inputs.commits, inputs.files)
-        pending = [o for o in outliers(inputs.commits, weigh, inputs.judgments) if o.slop is None]
+        settings = inputs.settings
+        weigh = weigher_for(inputs.commits, inputs.files, settings)
+        pending = [o for o in outliers(inputs.commits, weigh, inputs.judgments, settings) if o.slop is None]
         if not pending:
             return
         lookup = self._lookup if self._lookup is not None else (await self._read()).models
@@ -480,9 +577,11 @@ async def _judge(self, repo: str, inputs: Inputs) -> None:
 
         client = self._http or httpx.AsyncClient()
         try:
-            for outlier in pending[: self._settings.judgments_per_tick]:
+            for outlier in pending[: self._limits.judgments_per_tick]:
                 try:
-                    slop, reason = await judge(repo, outlier, endpoint, client, self._calls)
+                    slop, reason = await judge(
+                        repo, outlier, endpoint, client, self._calls, guidance=settings.judge_prompt
+                    )
                 except BackgroundCallRefused:
                     break
                 except (httpx.HTTPError, ValueError) as exc:
@@ -494,19 +593,77 @@ async def _judge(self, repo: str, inputs: Inputs) -> None:
             if self._http is None:
                 await client.aclose()
 
+    # ---- the schedule ----
+
+    def wait_seconds(self) -> float:
+        """How long the schedule waits after a look: :data:`LOOK_SECONDS`, or less when a run falls due sooner."""
+        if self._due is None:
+            return 0.0
+        return min(LOOK_SECONDS, max(0.0, (self._due - self._clock()).total_seconds()))
+
+    def _changed(self, read: MeterRead) -> list[str]:
+        """The repositories the last run read whose configuration version is another now."""
+        return [repo for repo, version in self._versions.items() if config_version(read.meter.repo(repo)) != version]
+
+    async def scheduled(self) -> bool:
+        """What the schedule does each time it looks; True when it ran.
+
+        Reads the settings first, so turning the meter on or off and a new
+        interval apply at this look. It runs when the interval (or, while a
+        history is behind, ``catchup_seconds``) has passed since the last run
+        ended, at once when the meter was just turned on, and at once when the
+        ``slop_meter`` section reads another :func:`config_version` for a
+        repository the last run read: that rescores it. With the meter off a
+        run only removes what left the scope (:meth:`prune_only`), once an
+        interval.
+        """
+        read = await self._read()
+        policy = read.meter.deployment()
+        turned_on = policy.enabled and self._enabled is False
+        if policy.enabled != self._enabled:
+            logger.info(
+                "slop_meter_on" if policy.enabled else "slop_meter_off",
+                reason="slop_meter.enabled in the settings document",
+            )
+            self._enabled = policy.enabled
+        last = self._last_pass
+        if last is not None and not turned_on:
+            next_run = last + timedelta(seconds=self._period(policy))
+            changed = self._changed(read) if policy.enabled and self._clock() < next_run else []
+            if self._clock() < next_run and not changed:
+                self._due = next_run
+                return False
+        else:
+            changed = []
+        if changed:
+            logger.info("slop_meter_settings_changed", repos=sorted(changed), hint="rescoring them now")
+        try:
+            if policy.enabled:
+                self._backlog = await self.tick(read)
+            else:
+                self._backlog = False
+                self._versions = {}
+                await self.prune_only(read)
+        finally:
+            self._last_pass = self._clock()
+            self._due = self._last_pass + timedelta(seconds=self._period(policy))
+        return True
+
+    def _period(self, policy: SlopMeterSettings) -> float:
+        """Seconds from the end of one run to the next: ``catchup_seconds`` while a history is behind, else the
+        interval."""
+        if self._backlog and policy.enabled:
+            return self._limits.catchup_seconds
+        return policy.interval_hours * 3600
+
     async def start(self) -> None:  # pragma: no cover - exercised by the app
-        if self._settings.interval_seconds <= 0:
-            # Off: nothing is read, but what was kept of a repository that left the scope still goes, once.
-            logger.info("slop_meter_off")
-            try:
-                await self.prune_only()
-            except Exception:  # noqa: BLE001 - the next start tries again
-                logger.warning("slop_meter_prune_failed", exc_info=True)
-            return
+        """Look for ever, whether the meter is on or off, so turning it on, or any change to the section, needs
+        no restart. The first look runs at once."""
         while True:
             try:
-                backlog = await self.tick()
+                await self.scheduled()
             except Exception:  # noqa: BLE001 - the loop goes on
                 logger.warning("slop_meter_tick_failed", exc_info=True)
-                backlog = False
-            await asyncio.sleep(self._settings.catchup_seconds if backlog else self._settings.interval_seconds)
+                if self._due is None or self._due <= self._clock():
+                    self._due = self._clock() + timedelta(seconds=LOOK_SECONDS)
+            await self._sleep(self.wait_seconds())
diff --git a/embry0/services/slop_meter/score.py b/embry0/services/slop_meter/score.py
index cbb1e0bd..1ad2a89f 100644
--- a/embry0/services/slop_meter/score.py
+++ b/embry0/services/slop_meter/score.py
@@ -6,6 +6,13 @@
 additions, dampened by the codebase's size; its capacity is the human session
 time behind it, as lines; the excess is slop, and the score is the history's
 slop over its cost. Pure functions over parsed rows: no git, no network.
+
+Every number the algorithm names (the size ramp, the hours a commit or a
+comment implies, the lines an hour covers, the weekly cap, the core team's
+ramp, the outlier thresholds) and the levels a score reads as are the
+settings document's ``slop_meter`` section (#169): each function takes the
+section as its repository reads it, and the section's defaults, the
+published values, when none is given.
 """
 
 from __future__ import annotations
@@ -17,36 +24,22 @@
 from datetime import UTC, date, datetime, timedelta
 
 from embry0.services.slop_meter.history import Commit, is_bot
+from embry0.settings.sections.slop_meter import SLOP_METER, SlopMeterSettings
 
-BOOTSTRAP_THRESHOLD = 5_000
-COMPLEXITY_WEIGHT = 0.05
-BASE_NEIGHBORHOOD = 1.0
-MARGINAL_HOURS_PER_SUBCOMMIT = 1.0
-AI_CO_AUTHOR_ATTENTION_WEIGHT = 0.8
-CO_AUTHOR_WEIGHTS = (0.5, 0.25, 0.125)
-LINES_PER_HOUR = 40.0
-CORE_RAMP_START = 10
-CORE_RAMP_END = 60
-WEEKLY_HOURS_CAP = 80.0
-OUTLIER_MIN_ADDITIONS = 2_000
-OUTLIERS_PER_YEAR = 4
-
-#: (upper bound, level, name), the score's interpretation.
-LEVELS: tuple[tuple[float, int, str], ...] = (
-    (0.2, 1, "Buttered Noodles"),
-    (0.4, 2, "Spaghetti Bolognese"),
-    (0.6, 3, "Lasagna"),
-    (0.8, 4, "Sloppy Joe"),
-    (math.inf, 5, "Just The Slop"),
-)
+#: The ``slop_meter`` section with nothing written: the published algorithm's values.
+DEFAULTS: SlopMeterSettings = SLOP_METER.defaults()
+#: The size past which the log bonus of the size dampening grows by ``complexity_weight`` per doubling.
+_COMPLEXITY_LINES = 100_000
 _YEAR = timedelta(days=365.25)
 
 
-def level_of(score: float) -> tuple[int, str]:
-    for bound, level, name in LEVELS:
+def level_of(score: float, settings: SlopMeterSettings = DEFAULTS) -> tuple[int, str]:
+    """The level (1 the least slop) and its name: the first whose bound the score is below, else the last."""
+    names = settings.level_names
+    for index, bound in enumerate(settings.level_bounds):
         if score < bound:
-            return level, name
-    return LEVELS[-1][1], LEVELS[-1][2]
+            return index + 1, names[index]
+    return len(names), names[-1]
 
 
 def week_of(at: datetime) -> date:
@@ -55,21 +48,26 @@ def week_of(at: datetime) -> date:
     return day - timedelta(days=day.weekday())
 
 
-def size_dampening(cumulative_lines: float) -> float:
-    """A line's weight by the codebase's size: a bootstrap ramp to 5,000 lines plus a slow log bonus."""
+def size_dampening(cumulative_lines: float, settings: SlopMeterSettings = DEFAULTS) -> float:
+    """A line's weight by the codebase's size: a bootstrap ramp to ``bootstrap_lines`` plus a slow log bonus."""
     lines = max(0.0, cumulative_lines)
-    return min(1.0, lines / BOOTSTRAP_THRESHOLD) + COMPLEXITY_WEIGHT * math.log2(1 + lines / 100_000)
+    return min(1.0, lines / settings.bootstrap_lines) + settings.complexity_weight * math.log2(
+        1 + lines / _COMPLEXITY_LINES
+    )
 
 
-def capped_hours(hours: float) -> float:
+def capped_hours(hours: float, settings: SlopMeterSettings = DEFAULTS) -> float:
     """Effective hours under the concave overtime curve: ``h − h³/(3·cap²)``, flat past the cap."""
-    h = min(max(0.0, hours), WEEKLY_HOURS_CAP)
-    return h - h**3 / (3 * WEEKLY_HOURS_CAP**2)
+    cap = settings.weekly_hours_cap
+    h = min(max(0.0, hours), cap)
+    return h - h**3 / (3 * cap**2)
 
 
-def core_factor(commits: int, total_commits: int) -> float:
-    """How much of a contributor's time counts: 0 below 10 commits, 1 at 60, up to 1.25× for a large share."""
-    ramp = min(1.0, max(0.0, (commits - CORE_RAMP_START) / (CORE_RAMP_END - CORE_RAMP_START)))
+def core_factor(commits: int, total_commits: int, settings: SlopMeterSettings = DEFAULTS) -> float:
+    """How much of a contributor's time counts: 0 below ``core_min_commits``, 1 at ``core_full_commits``, up to
+    1.25× for a large share."""
+    start, end = settings.core_min_commits, settings.core_full_commits
+    ramp = min(1.0, max(0.0, (commits - start) / (end - start)))
     share = commits / total_commits if total_commits else 0.0
     return ramp * (1 + 0.25 * share)
 
@@ -117,40 +115,47 @@ def contributor_of(login: str, logins: Mapping[str, str]) -> str:
 
 
 def weekly_capacity(
-    commits: Sequence[Commit], events: Iterable[Event], logins: Mapping[str, str]
+    commits: Sequence[Commit],
+    events: Iterable[Event],
+    logins: Mapping[str, str],
+    settings: SlopMeterSettings = DEFAULTS,
 ) -> dict[str, dict[date, float]]:
     """Each contributor's attention spent per week, in lines (already capped and core-weighted)."""
+    s = settings
+    shares = s.coauthor_shares
     neighborhoods: dict[str, list[tuple[datetime, datetime]]] = defaultdict(list)
     authored: dict[str, int] = defaultdict(int)
     for c in commits:
         if c.bot:
             continue
         authored[c.author] += 1
-        hours = BASE_NEIGHBORHOOD + c.subcommits * MARGINAL_HOURS_PER_SUBCOMMIT
+        hours = s.commit_hours + c.subcommits * s.subcommit_hours
         if c.ai_coauthor:
-            hours *= AI_CO_AUTHOR_ATTENTION_WEIGHT
+            hours *= s.ai_coauthor_share
         neighborhoods[c.author].append((c.at - timedelta(hours=hours), c.at))
         for i, (_name, email) in enumerate(c.coauthors):
-            weight = CO_AUTHOR_WEIGHTS[min(i, len(CO_AUTHOR_WEIGHTS) - 1)]
-            neighborhoods[email.lower()].append((c.at - timedelta(hours=BASE_NEIGHBORHOOD * weight), c.at))
+            share = shares[min(i, len(shares) - 1)]
+            neighborhoods[email.lower()].append((c.at - timedelta(hours=s.commit_hours * share), c.at))
     for e in events:
         if is_bot(e.login, ""):
             continue
-        neighborhoods[contributor_of(e.login, logins)].append((e.at - timedelta(hours=BASE_NEIGHBORHOOD), e.at))
+        neighborhoods[contributor_of(e.login, logins)].append((e.at - timedelta(hours=s.event_hours), e.at))
     total = sum(authored.values())
     # A small repository has no core team to measure drive-bys against: when
-    # no author reaches CORE_RAMP_START commits, everyone's time counts in
+    # no author reaches core_min_commits commits, everyone's time counts in
     # full. Otherwise its every author would count for nothing and all its
     # code read as slop. This is embry0's departure from the published
-    # algorithm; a repository with a core contributor is scored as written.
-    small = not authored or max(authored.values()) < CORE_RAMP_START
+    # algorithm (small_repository_in_full); a repository with a core
+    # contributor is scored as written.
+    small = s.small_repository_in_full and (not authored or max(authored.values()) < s.core_min_commits)
     out: dict[str, dict[date, float]] = {}
     for who, spans in neighborhoods.items():
-        factor = 1.0 if small else core_factor(authored.get(who, 0), total)
+        factor = 1.0 if small else core_factor(authored.get(who, 0), total, s)
         if factor <= 0:
             continue
         out[who] = {
-            week: capped_hours(hours * factor) * LINES_PER_HOUR for week, hours in _hours_by_week(_merge(spans)).items()
+            week: capped_hours(hours * factor, s) * s.lines_per_hour
+            for week, hours in _hours_by_week(_merge(spans)).items()
         }
     return out
 
@@ -198,8 +203,14 @@ def commit_lines(commit: Commit, weigh: Callable[[str], float]) -> tuple[float,
     return add, delete
 
 
-def outliers(commits: Sequence[Commit], weigh: Callable[[str], float], judgments: Mapping[str, bool]) -> list[Outlier]:
-    """The top ``⌈4 × age in years⌉`` commits of at least 2,000 net weighted additions, with what is known of them.
+def outliers(
+    commits: Sequence[Commit],
+    weigh: Callable[[str], float],
+    judgments: Mapping[str, bool],
+    settings: SlopMeterSettings = DEFAULTS,
+) -> list[Outlier]:
+    """The top ``⌈outliers_per_year × age in years⌉`` commits of at least ``outlier_min_lines`` net weighted
+    additions, with what is known of them.
 
     At least one commit is considered, however young the repository. The
     repository's first two commits are never slop; the rest are what the model
@@ -211,12 +222,12 @@ def outliers(commits: Sequence[Commit], weigh: Callable[[str], float], judgments
     # At least one: a history that spans no time (one commit, or one day of
     # commits at one instant) would otherwise judge none, and its first
     # commit, setup the spec always excuses, would count as slop.
-    count = max(1, math.ceil(OUTLIERS_PER_YEAR * (last - first) / _YEAR))
+    count = max(1, math.ceil(settings.outliers_per_year * (last - first) / _YEAR))
     nets: list[tuple[float, int, Commit]] = []
     for index, c in enumerate(commits):
         add, delete = commit_lines(c, weigh)
         net = max(0.0, add - delete)
-        if net >= OUTLIER_MIN_ADDITIONS:
+        if net >= settings.outlier_min_lines:
             nets.append((net, index, c))
     top = sorted(nets, key=lambda item: -item[0])[:count]
     sizes = _sizes_by_week(commits, weigh)
@@ -244,6 +255,7 @@ def meters(
     weigh: Callable[[str], float],
     judgments: Mapping[str, bool],
     area_of: Callable[[str], str | None] = lambda _path: None,
+    settings: SlopMeterSettings = DEFAULTS,
 ) -> dict[str, Meter]:
     """The repository's meter (key ``""``) and each area's, from the history oldest first.
 
@@ -251,11 +263,12 @@ def meters(
     the repository's size; its capacity is each contributor's weekly capacity
     apportioned by the share of their weighted churn that week in the area
     (their history-wide share in a week without commits of their own).
+    ``settings`` is the ``slop_meter`` section as the repository reads it.
     """
     commits = sorted(commits, key=lambda c: c.at)
     if not commits:
-        return {"": Meter(0.0, 1, LEVELS[0][2], False)}
-    found = outliers(commits, weigh, judgments)
+        return {"": Meter(0.0, 1, settings.level_names[0], False)}
+    found = outliers(commits, weigh, judgments, settings)
     left_out = {o.commit.sha for o in found if o.slop is not True}
     provisional = any(o.slop is None for o in found)
 
@@ -290,7 +303,7 @@ def meters(
                 churn[scope][(c.author, week)] += scope_add + scope_del
                 churn_all[scope][c.author] += scope_add + scope_del
 
-    capacity_by_who = weekly_capacity(commits, events, logins)
+    capacity_by_who = weekly_capacity(commits, events, logins, settings)
     first_week = week_of(commits[0].at)
     last_week = week_of(commits[-1].at)
     weeks = [first_week + timedelta(weeks=i) for i in range((last_week - first_week).days // 7 + 1)]
@@ -300,7 +313,7 @@ def meters(
     size = 0.0
     for week in weeks:
         size = max(0.0, size + adds[""][week] - dels[""][week])
-        damp[week] = size_dampening(size)
+        damp[week] = size_dampening(size, settings)
 
     out: dict[str, Meter] = {}
     for scope in adds:
@@ -332,7 +345,7 @@ def meters(
             cum_slop += slop
             series.append(Week(week, cost, capacity, slop, scope_size, cum_slop / cum_cost if cum_cost else 0.0))
         score = cum_slop / cum_cost if cum_cost else 0.0
-        level, name = level_of(score)
+        level, name = level_of(score, settings)
         out[scope] = Meter(score, level, name, provisional, series, len(commits))
-    out.setdefault("", Meter(0.0, 1, LEVELS[0][2], provisional, [], len(commits)))
+    out.setdefault("", Meter(0.0, 1, settings.level_names[0], provisional, [], len(commits)))
     return out
diff --git a/embry0/services/slop_meter/weights.py b/embry0/services/slop_meter/weights.py
index a1084f74..52116b31 100644
--- a/embry0/services/slop_meter/weights.py
+++ b/embry0/services/slop_meter/weights.py
@@ -2,9 +2,13 @@
 
 After Slop-O-Meter's published slop score algorithm
 (https://github.com/slop-o-meter/slop-o-meter, docs/slop-score-algorithm.md):
-a line weighs by its file's type, half for tests and examples, nothing for
-non-code, vendored, generated or linter-ignored files, and nothing for an
-outlier file smaller than its fair share.
+a line weighs by its file's type, a share of that for tests and examples,
+nothing for non-code, vendored, generated or linter-ignored files, and
+nothing for an outlier file smaller than its fair share. What each kind of
+file weighs, which directories are vendored and what a test is are the
+settings document's ``slop_meter`` section (#169), read as a
+:class:`FileRules`; which ignore lists are read and the outlier rule are the
+algorithm's.
 """
 
 from __future__ import annotations
@@ -13,71 +17,95 @@
 import re
 import tomllib
 from collections.abc import Iterable, Mapping
+from dataclasses import dataclass
 from functools import lru_cache
 from statistics import quantiles
 from typing import Any
 
-#: A test or example file's weight, as a share of its type's.
-NON_PRODUCTION_WEIGHT = 0.5
-
-_CORE = (
-    "py", "pyi", "ts", "mts", "cts", "js", "mjs", "cjs", "go", "rs", "java", "kt", "kts", "scala", "c", "h",
-    "cc", "cpp", "cxx", "hpp", "hh", "cs", "rb", "php", "swift", "m", "mm", "ex", "exs", "erl", "clj", "cljs",
-    "hs", "ml", "fs", "lua", "pl", "pm", "r", "jl", "dart", "zig", "nim", "groovy", "sh", "bash", "zsh",
-    "ps1", "tf", "sol", "proto", "graphql", "gql",
-)  # fmt: skip
-_UI = ("tsx", "jsx", "vue", "svelte", "astro", "html", "htm", "erb", "hbs", "ejs", "jinja", "j2", "twig", "liquid")
-_STYLE = ("css", "scss", "sass", "less", "styl", "pcss")
-TYPE_WEIGHTS: dict[str, float] = {
-    **dict.fromkeys(_CORE, 1.0),
-    "sql": 0.8,
-    **dict.fromkeys(_UI, 0.5),
-    **dict.fromkeys(_STYLE, 0.3),
-}
-
-_VENDORED_DIRS = ("vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components")
-_GENERATED = re.compile(r"(\.min\.(js|css)|\.bundle\.js|\.map|\.d\.ts)\Z")
-_NON_PRODUCTION_DIRS = (
-    "__tests__",
-    "tests",
-    "test",
-    "spec",
-    "specs",
-    "examples",
-    "example",
-    "demos",
-    "demo",
-    "samples",
-    "sample",
-    "fixtures",
-    "testdata",
-)
-_NON_PRODUCTION_FILE = re.compile(r"(\.(test|spec|stories|story)\.[^.]+|_test\.(go|py|rb|exs?)|_spec\.rb)\Z|(\A|/)test_[^/]+\.py\Z")  # fmt: skip
+from embry0.services.slop_meter.globs import compile_glob, marked
+from embry0.settings.sections.slop_meter import SLOP_METER, SlopMeterSettings
+
+_LITERAL_SUFFIX = re.compile(r"\*[^*?/]+\Z")
+
+
+@lru_cache(maxsize=4096)
+def _matcher(glob: str) -> tuple[str, Any]:
+    """How one glob is checked: a name's suffix for ``*`` and a literal (``*.py``, most globs), else its
+    expression (:func:`embry0.services.slop_meter.globs.compile_glob`)."""
+    lowered = glob.lower()
+    if _LITERAL_SUFFIX.match(lowered):
+        return lowered[1:], None
+    return lowered, compile_glob(lowered)
 
-#: The ignore files a linter or formatter reads (gitignore-style globs), at the repository root.
-IGNORE_FILES = (".prettierignore", ".eslintignore", ".stylelintignore")
-CONFIG_FILES = (*IGNORE_FILES, ".gitattributes", "biome.json", "pyproject.toml", "ruff.toml", ".ruff.toml")
 
+def _hit(matcher: tuple[str, Any], path: str, name: str) -> bool:
+    text, pattern = matcher
+    if pattern is None:
+        return name.endswith(text)
+    return pattern.fullmatch(path if "/" in text else name) is not None
 
-def _extension(path: str) -> str:
-    name = path.rsplit("/", 1)[-1]
-    return name.rsplit(".", 1)[-1].lower() if "." in name else ""
 
+@dataclass(frozen=True)
+class FileRules:
+    """What a changed line of each file weighs, from the ``slop_meter`` section (:meth:`of`).
 
-def type_weight(path: str) -> float:
-    """A path's weight before ignore lists and outliers: its type's, halved for tests and examples, 0 when excluded."""
-    lowered = path.lower()
-    parts = lowered.split("/")
-    if any(p in _VENDORED_DIRS for p in parts[:-1]) or _GENERATED.search(lowered):
-        return 0.0
-    weight = TYPE_WEIGHTS.get(_extension(lowered), 0.0)
-    if weight and (any(p in _NON_PRODUCTION_DIRS for p in parts[:-1]) or _NON_PRODUCTION_FILE.search(lowered)):
-        weight *= NON_PRODUCTION_WEIGHT
-    return weight
+    ``weights`` are ``(glob, weight)`` pairs in the order they are tried:
+    the longest glob first, so the first that matches is the one that wins,
+    and between globs of one length the first in alphabetical order.
+    """
+
+    weights: tuple[tuple[str, float], ...]
+    excluded_dirs: frozenset[str]
+    test_dirs: frozenset[str]
+    test_files: tuple[str, ...]
+    test_marks: frozenset[str]
+    test_weight: float
+
+    @classmethod
+    def of(cls, settings: SlopMeterSettings) -> FileRules:
+        ordered = sorted(settings.weights.items(), key=lambda item: (-len(item[0]), item[0]))
+        return cls(
+            weights=tuple((glob.lower(), float(weight)) for glob, weight in ordered),
+            excluded_dirs=frozenset(name.lower() for name in settings.excluded_dirs),
+            test_dirs=frozenset(name.lower() for name in settings.test_dirs),
+            test_files=tuple(glob.lower() for glob in settings.test_files),
+            test_marks=frozenset(mark.lower() for mark in settings.test_marks),
+            test_weight=float(settings.test_weight),
+        )
+
+    def weight(self, path: str) -> float:
+        """A path's weight before ignore lists and outliers: its glob's, a share for tests, 0 when excluded."""
+        lowered = path.lower()
+        parts = lowered.split("/")
+        name = parts[-1]
+        if any(p in self.excluded_dirs for p in parts[:-1]):
+            return 0.0
+        weight = next((w for glob, w in self.weights if _hit(_matcher(glob), lowered, name)), 0.0)
+        if weight and (
+            any(p in self.test_dirs for p in parts[:-1])
+            or marked(name, self.test_marks)
+            or any(_hit(_matcher(glob), lowered, name) for glob in self.test_files)
+        ):
+            weight *= self.test_weight
+        return weight
+
+
+#: The rules of the section's defaults: what every reading used before the section, and still uses where
+#: nothing is written.
+DEFAULT_RULES = FileRules.of(SLOP_METER.defaults())
+
+
+def type_weight(path: str, rules: FileRules = DEFAULT_RULES) -> float:
+    """A path's weight before ignore lists and outliers, under ``rules`` (the defaults when none is given)."""
+    return rules.weight(path)
 
 
 # ---- ignore lists ----
 
+#: The ignore files a linter or formatter reads (gitignore-style globs), at the repository root.
+IGNORE_FILES = (".prettierignore", ".eslintignore", ".stylelintignore")
+CONFIG_FILES = (*IGNORE_FILES, ".gitattributes", "biome.json", "pyproject.toml", "ruff.toml", ".ruff.toml")
+
 
 def _ignore_lines(text: str) -> list[str]:
     out = []
@@ -188,19 +216,26 @@ def outlier_files(sizes: Mapping[str, int]) -> set[str]:
 
 
 class Weigher:
-    """A repository's line weights: by type, ignore lists, and outlier files."""
+    """A repository's line weights: by ``rules`` (its ``slop_meter`` section), ignore lists, and outlier files."""
 
-    def __init__(self, patterns: Iterable[str] = (), excluded: Iterable[str] = ()) -> None:
+    def __init__(
+        self, patterns: Iterable[str] = (), excluded: Iterable[str] = (), rules: FileRules = DEFAULT_RULES
+    ) -> None:
         self._patterns = tuple(patterns)
         self._excluded = frozenset(excluded)
+        self._rules = rules
         self._cache: dict[str, float] = {}
 
+    @property
+    def rules(self) -> FileRules:
+        return self._rules
+
     def __call__(self, path: str) -> float:
         cached = self._cache.get(path)
         if cached is None:
             if path in self._excluded or (self._patterns and ignored(path, self._patterns)):
                 cached = 0.0
             else:
-                cached = type_weight(path)
+                cached = self._rules.weight(path)
             self._cache[path] = cached
         return cached
diff --git a/embry0/settings/document.py b/embry0/settings/document.py
index 63cd22ce..81eea4dd 100644
--- a/embry0/settings/document.py
+++ b/embry0/settings/document.py
@@ -677,11 +677,25 @@ def read_sections(catalog: Catalog, data: Mapping[str, Any]) -> Sections:
 # ---- text -----------------------------------------------------------------------------
 
 
+class _BlockDumper(yaml.SafeDumper):
+    """The safe dumper, writing a text of several lines as a literal block (``|``), line for line."""
+
+
+def _represent_text(dumper: yaml.SafeDumper, data: str) -> yaml.ScalarNode:
+    # A text the literal style cannot hold (a line ending in a blank, say) falls back to the
+    # emitter's own choice, so the YAML always reads back as the same text.
+    return dumper.represent_scalar("tag:yaml.org,2002:str", data, style="|" if "\n" in data else None)
+
+
+_BlockDumper.add_representer(str, _represent_text)
+
+
 def dump_yaml(values: Mapping[str, Any]) -> str:
-    """``values`` as block-style YAML, keys in their given order; ``""`` for nothing."""
+    """``values`` as block-style YAML, keys in their given order, a text of several lines as a literal block;
+    ``""`` for nothing."""
     if not values:
         return ""
-    return yaml.safe_dump(dict(values), sort_keys=False, default_flow_style=False, allow_unicode=True)
+    return yaml.dump(dict(values), Dumper=_BlockDumper, sort_keys=False, default_flow_style=False, allow_unicode=True)
 
 
 def _comment(comment: str, indent: str = "", newline: str = "\n") -> str:
diff --git a/embry0/settings/sections/__init__.py b/embry0/settings/sections/__init__.py
index f701e9be..a182fa5f 100644
--- a/embry0/settings/sections/__init__.py
+++ b/embry0/settings/sections/__init__.py
@@ -24,6 +24,7 @@
 from embry0.settings.sections.leads import LEADS
 from embry0.settings.sections.salvage import SALVAGE
 from embry0.settings.sections.scout import SCOUT
+from embry0.settings.sections.slop_meter import SLOP_METER
 from embry0.settings.sections.ui import UI
 
 CATALOG: Catalog = Catalog(
@@ -37,6 +38,7 @@
         LEADS,
         SALVAGE,
         SCOUT,
+        SLOP_METER,
         UI,
     ]
 )
diff --git a/embry0/settings/sections/slop_meter.py b/embry0/settings/sections/slop_meter.py
new file mode 100644
index 00000000..280322b7
--- /dev/null
+++ b/embry0/settings/sections/slop_meter.py
@@ -0,0 +1,556 @@
+"""The ``slop_meter`` section: how the Slop-O-Meter weighs lines and attention, and how often it reads.
+
+An operator writes it the way they would say it::
+
+    slop_meter:
+      interval_hours: 12          # score twice a day
+      weights:                    # merged entry by entry over the defaults
+        "*.sql": 1.0              # SQL is core logic here
+        "db/migrations/**": 0     # generated migrations weigh nothing
+      excluded_dirs: [vendor, node_modules, third_party, generated]
+      lines_per_hour: 30          # a team that reads every line twice
+      level_names: [Clean, Fine, Mixed, Sloppy, Slop]
+      bots: [release-bot, ci@acme.example]
+
+Every default is the published algorithm's value as the meter read it before
+this section (docs/slop-meter.md credits it), so a deployment that writes
+nothing scores exactly as it did. ``small_repository_in_full`` is the one
+place embry0 departs from that algorithm on purpose, kept as data so an
+organization can score as the algorithm is written.
+
+**What a key changes.** Every key but ``enabled``, ``interval_hours``,
+``api_calls_per_tick``, ``rate_reserve`` and ``judge_prompt``
+(:data:`NOT_SCORED`) is what a score is computed from. Each score row records
+:func:`config_version`, a digest of those keys as its repository read them;
+a change to one of them changes the digest, and the meter rescores every
+repository it reads that the change reaches within five minutes, not at its
+next daily run. ``judge_prompt`` applies to the outlier commits judged after
+it changes: a judgment is kept and never asked again.
+
+**Layers.** What counts as code, how fast a team attends to it, where the
+level bands fall, the judge's guidance and the owner's own bots are an
+organization's to say for its repositories; what counts as code is also a
+repository's own, for its layout (``weights``, ``excluded_dirs``,
+``test_dirs``, ``test_files``, ``test_marks``). ``weights`` is merged entry
+by entry, so a layer adds or changes the globs it names and keeps every
+other. ``api_calls_per_tick`` and ``rate_reserve`` bound the forge calls one
+tick makes with a credential, so an organization may set them for the
+credential it reads with. Whether the meter runs and how often are the
+deployment's alone.
+
+**Before this section** the reading pace was ``SLOP_METER_INTERVAL_SECONDS``
+(``0`` turned the reading off), ``SLOP_METER_API_CALLS_PER_TICK`` and
+``SLOP_METER_RATE_RESERVE``: the first start of this release imports them
+once (``env`` below). An owner's own bots were ``slop_meter_bots`` on its
+organization row (#184); the same start copies each into the organization's
+layer as ``bots`` (:data:`embry0.services.organizations.MOVED_SETTINGS`).
+Everything else was a constant in the meter's code.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import unicodedata
+from typing import Annotated, Any, Final
+
+from pydantic import Field, StringConstraints, field_validator, model_validator
+
+from embry0.services.slop_meter.globs import (
+    MAX_DIR_LENGTH,
+    MAX_GLOB_LENGTH,
+    MAX_MARK_LENGTH,
+    check_dir_name,
+    check_glob,
+    check_mark,
+)
+from embry0.settings.registry import EnvImport, Section, SectionModel, refuse_unprintable
+
+# ---- the defaults: the published algorithm's values, as the meter read them before this section ----
+
+#: Core logic: a changed line weighs in full.
+_CORE: Final = (
+    "py", "pyi", "ts", "mts", "cts", "js", "mjs", "cjs", "go", "rs", "java", "kt", "kts", "scala", "c", "h",
+    "cc", "cpp", "cxx", "hpp", "hh", "cs", "rb", "php", "swift", "m", "mm", "ex", "exs", "erl", "clj", "cljs",
+    "hs", "ml", "fs", "lua", "pl", "pm", "r", "jl", "dart", "zig", "nim", "groovy", "sh", "bash", "zsh",
+    "ps1", "tf", "sol", "proto", "graphql", "gql",
+)  # fmt: skip
+#: User interface code and templates.
+_UI: Final = ("tsx", "jsx", "vue", "svelte", "astro", "html", "htm", "erb", "hbs", "ejs", "jinja", "j2", "twig", "liquid")  # fmt: skip
+#: Styling.
+_STYLE: Final = ("css", "scss", "sass", "less", "styl", "pcss")
+#: Minified, bundled, source-map and declaration files: generated, so they weigh nothing.
+_GENERATED: Final = ("*.min.js", "*.min.css", "*.bundle.js", "*.map", "*.d.ts")
+
+DEFAULT_WEIGHTS: Final[dict[str, float]] = {
+    **{f"*.{extension}": 1.0 for extension in _CORE},
+    "*.sql": 0.8,
+    **{f"*.{extension}": 0.5 for extension in _UI},
+    **{f"*.{extension}": 0.3 for extension in _STYLE},
+    **dict.fromkeys(_GENERATED, 0.0),
+}
+DEFAULT_EXCLUDED_DIRS: Final = ("vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components")  # fmt: skip
+DEFAULT_TEST_DIRS: Final = (
+    "__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample",
+    "fixtures", "testdata",
+)  # fmt: skip
+DEFAULT_TEST_FILES: Final = ("*_test.go", "*_test.py", "*_test.rb", "*_test.ex", "*_test.exs", "*_spec.rb", "test_?*.py")  # fmt: skip
+DEFAULT_TEST_MARKS: Final = ("test", "spec", "stories", "story")
+DEFAULT_LEVEL_BOUNDS: Final = (0.2, 0.4, 0.6, 0.8)
+DEFAULT_LEVEL_NAMES: Final = ("Buttered Noodles", "Spaghetti Bolognese", "Lasagna", "Sloppy Joe", "Just The Slop")
+DEFAULT_JUDGE_PROMPT: Final = """\
+You judge one large commit of a software repository: did it add bulk code no
+person wrote or reviewed line by line (slop, such as a large AI-generated
+change), or is its size explained by something else (not slop: the project's
+initial import, a code drop moved in from elsewhere, a restructuring that moved
+files, a vendored or generated library, a data or fixture dump)?
+Judge from what the message and the files say. When it is unclear, answer
+slop: false only if the files themselves look moved, vendored or generated."""
+
+#: The number of levels. Five, as the published algorithm reads a score; their bounds and names are data.
+LEVELS: Final = 5
+#: How often the meter reads by default, and the least ``interval_hours`` takes: a quarter hour.
+DEFAULT_INTERVAL_HOURS: Final = 24.0
+MIN_INTERVAL_HOURS: Final = 0.25
+#: The most entries ``weights`` holds.
+MAX_WEIGHTS: Final = 1000
+#: The most entries ``bots`` and ``ai_agents`` hold, as ``slop_meter_bots`` held on the organization row.
+MAX_IDENTITIES: Final = 100
+MAX_IDENTITY_LENGTH: Final = 200
+MAX_LEVEL_NAME_LENGTH: Final = 60
+MAX_JUDGE_PROMPT_LENGTH: Final = 4000
+
+#: The keys a score is not computed from: whether and how often the meter reads, its forge budget, and the
+#: guidance of judgments still to come. :func:`config_version` digests every other key.
+NOT_SCORED: Final = frozenset({"enabled", "interval_hours", "api_calls_per_tick", "rate_reserve", "judge_prompt"})
+
+Glob = Annotated[str, StringConstraints(max_length=MAX_GLOB_LENGTH)]
+DirName = Annotated[str, StringConstraints(max_length=MAX_DIR_LENGTH)]
+Mark = Annotated[str, StringConstraints(max_length=MAX_MARK_LENGTH)]
+Identity = Annotated[str, StringConstraints(max_length=MAX_IDENTITY_LENGTH)]
+LevelName = Annotated[str, StringConstraints(max_length=MAX_LEVEL_NAME_LENGTH)]
+
+
+def enabled_from_env(value: Any) -> bool:
+    """``SLOP_METER_INTERVAL_SECONDS`` as the loop read it: ``0`` (or less) turned the reading off."""
+    return float(value) > 0
+
+
+def interval_from_env(value: Any) -> float:
+    """``SLOP_METER_INTERVAL_SECONDS`` in hours, at least a quarter hour; ``0``, which turned the reading off and
+    is ``enabled: false`` now, reads as the default, so nothing is imported for it."""
+    seconds = float(value)
+    if seconds <= 0:
+        return DEFAULT_INTERVAL_HOURS
+    return max(MIN_INTERVAL_HOURS, seconds / 3600)
+
+
+def _each(values: tuple[str, ...], check: Any, what: str) -> tuple[str, ...]:
+    """``values`` when ``check`` takes each and no two are the same without regard to case."""
+    for position, value in enumerate(values, start=1):
+        try:
+            check(value)
+        except ValueError as exc:
+            raise ValueError(f"{what} {position}: {exc}") from None
+    if len({value.lower() for value in values}) != len(values):
+        raise ValueError(f"name each {what} once")
+    return values
+
+
+def _identity(text: str) -> str:
+    if not text.strip():
+        raise ValueError("write a name, an address or a login, not blanks")
+    if text != text.strip():
+        raise ValueError("an identity has no blanks around it")
+    refuse_unprintable(text, what="an identity")
+    return text
+
+
+def _agent(text: str) -> str:
+    if not text or any(char.isspace() for char in text):
+        raise ValueError("an AI agent is the start of its commit address, such as aider@, with no blanks")
+    refuse_unprintable(text, what="an AI agent's address")
+    return text
+
+
+class SlopMeterSettings(SectionModel):
+    # ---- when it reads ----
+    enabled: bool = Field(
+        default=True,
+        description=(
+            "The meter reads the repositories enrolled in background.slop_meter and scores them. false stops the "
+            "reading and the scoring everywhere; what was kept of a repository that left the scope is still "
+            "removed after background.prune_after_days. Was SLOP_METER_INTERVAL_SECONDS=0. The deployment's alone."
+        ),
+    )
+    interval_hours: float = Field(
+        default=DEFAULT_INTERVAL_HOURS,
+        ge=MIN_INTERVAL_HOURS,
+        le=8760,
+        description=(
+            "Hours between two runs over every enrolled repository: fetch, read the next part of its history and "
+            "events, and rescore it once caught up. While a history is still being read the meter comes back "
+            "sooner (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At least a quarter hour. "
+            "Was SLOP_METER_INTERVAL_SECONDS. The deployment's alone."
+        ),
+    )
+    api_calls_per_tick: int = Field(
+        default=200,
+        ge=0,
+        le=10_000,
+        description=(
+            "Forge API calls one run may make with one credential, shared round-robin by the repositories read "
+            "with it, to read comments, reviews and logins. Where repositories of organizations that set "
+            "different values are read with one credential, the smallest applies. Git fetches are not API calls."
+        ),
+    )
+    rate_reserve: int = Field(
+        default=2_000,
+        ge=0,
+        le=100_000,
+        description=(
+            "The rate limit a credential keeps for the jobs that use it: once its remaining calls "
+            "(X-RateLimit-Remaining) drop below this, the run makes no further call with it. Where organizations "
+            "that set different values share one credential, the largest applies."
+        ),
+    )
+    # ---- what a changed line weighs ----
+    weights: dict[Glob, float] = Field(
+        default_factory=lambda: dict(DEFAULT_WEIGHTS),
+        max_length=MAX_WEIGHTS,
+        description=(
+            "What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so "
+            "data, documents and binaries never count. A glob with no '/' matches a file's name in any directory "
+            "(*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' "
+            "matches within one name, '?' one character, '**' any directories. Where several match, the longest "
+            "glob wins (*.min.js over *.js). Write globs in lowercase, quoted: matching ignores case, and YAML "
+            "reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and "
+            "keeps every other, so a glob set to 0 stops counting."
+        ),
+    )
+    excluded_dirs: tuple[DirName, ...] = Field(
+        default=DEFAULT_EXCLUDED_DIRS,
+        max_length=100,
+        description=(
+            "Directories whose files weigh nothing, each one name matched at any depth: vendored and third-party "
+            "code. A list replaces the one it inherits whole; [] excludes none."
+        ),
+    )
+    test_dirs: tuple[DirName, ...] = Field(
+        default=DEFAULT_TEST_DIRS,
+        max_length=100,
+        description=(
+            "Directories whose files are tests or examples, each one name matched at any depth: their lines weigh "
+            "test_weight of what weights says. A list replaces the one it inherits whole."
+        ),
+    )
+    test_files: tuple[Glob, ...] = Field(
+        default=DEFAULT_TEST_FILES,
+        max_length=200,
+        description=(
+            "Globs of test and example files, in the grammar of weights (*_test.go, test_?*.py): their lines weigh "
+            "test_weight of what weights says. A list replaces the one it inherits whole."
+        ),
+    )
+    test_marks: tuple[Mark, ...] = Field(
+        default=DEFAULT_TEST_MARKS,
+        max_length=50,
+        description=(
+            "Words that mark a test or example file when they come just before its extension: test marks "
+            "a.test.ts and b.test.py, but not a.test.helper.ts. Their lines weigh test_weight of what weights "
+            "says. A list replaces the one it inherits whole."
+        ),
+    )
+    test_weight: float = Field(
+        default=0.5,
+        ge=0,
+        le=1,
+        description="A test or example file's lines weigh this share of what their file's glob in weights says.",
+    )
+    # ---- the codebase's size ----
+    bootstrap_lines: int = Field(
+        default=5_000,
+        ge=1,
+        le=10_000_000,
+        description=(
+            "Size dampening: while a codebase holds fewer weighted lines than this, a week's lines cost in "
+            "proportion to its size, so a young project's first lines cost little; from this size on, in full."
+        ),
+    )
+    complexity_weight: float = Field(
+        default=0.05,
+        ge=0,
+        le=1,
+        description=(
+            "Size dampening: how much more a line costs as the codebase grows, per doubling past 100,000 weighted "
+            "lines (the cost is min(1, size / bootstrap_lines) + complexity_weight × log2(1 + size / 100,000))."
+        ),
+    )
+    # ---- the attention people spend ----
+    commit_hours: float = Field(
+        default=1.0,
+        gt=0,
+        le=24,
+        description="Hours of a person's attention each commit they author implies, before its time.",
+    )
+    subcommit_hours: float = Field(
+        default=1.0,
+        ge=0,
+        le=24,
+        description=(
+            "Hours more for each commit a squash merge folded in (a body that lists two or more bullet lines)."
+        ),
+    )
+    coauthor_shares: tuple[float, ...] = Field(
+        default=(0.5, 0.25, 0.125),
+        min_length=1,
+        max_length=10,
+        description=(
+            "Each human Co-authored-by trailer implies this share of commit_hours, in trailer order; the last "
+            "share applies to every co-author after it. Each from 0 to 1."
+        ),
+    )
+    ai_coauthor_share: float = Field(
+        default=0.8,
+        ge=0,
+        le=1,
+        description="A commit with an AI co-author implies this share of the hours its author's commit would.",
+    )
+    event_hours: float = Field(
+        default=1.0,
+        ge=0,
+        le=24,
+        description="Hours of attention each comment, review comment and review on the forge implies (GitHub only).",
+    )
+    lines_per_hour: float = Field(
+        default=40.0,
+        gt=0,
+        le=10_000,
+        description="Weighted lines one hour of a person's attention covers.",
+    )
+    weekly_hours_cap: float = Field(
+        default=80.0,
+        gt=0,
+        le=168,
+        description=(
+            "The most hours one person's week counts, on a concave curve (h − h³/(3·cap²)), so overtime counts "
+            "for less and nothing past the cap."
+        ),
+    )
+    # ---- who counts as the core team ----
+    core_min_commits: int = Field(
+        default=10,
+        ge=0,
+        le=100_000,
+        description=(
+            "Authors with fewer human commits than this are drive-bys: their time counts for nothing. Their share "
+            "rises to full at core_full_commits, and up to a quarter more for a large share of the history."
+        ),
+    )
+    core_full_commits: int = Field(
+        default=60,
+        ge=1,
+        le=100_000,
+        description="The human commits at which an author's time counts in full. More than core_min_commits.",
+    )
+    small_repository_in_full: bool = Field(
+        default=True,
+        description=(
+            "When no author has reached core_min_commits, everyone's time counts in full: a small repository has "
+            "no core team to call anyone a drive-by, and read literally every author of it counts for nothing "
+            "and all its code reads as slop. embry0's departure from the published algorithm; false scores such "
+            "a repository as the algorithm is written."
+        ),
+    )
+    # ---- outlier commits ----
+    outlier_min_lines: int = Field(
+        default=2_000,
+        ge=1,
+        le=10_000_000,
+        description=(
+            "Net weighted lines a commit must add to be an outlier, judged by a model on "
+            "background_models.slop_judge: slop, or a code drop, an import or a move that is not."
+        ),
+    )
+    outliers_per_year: int = Field(
+        default=4,
+        ge=0,
+        le=365,
+        description=(
+            "Outlier commits judged per year of the project's age, the largest first; at least one however young."
+        ),
+    )
+    judge_prompt: str = Field(
+        default=DEFAULT_JUDGE_PROMPT,
+        min_length=1,
+        max_length=MAX_JUDGE_PROMPT_LENGTH,
+        description=(
+            "What the model judging an outlier commit is told slop is and is not. The answer's form (JSON with "
+            "slop and a reason) is added after it. Applies to commits judged after it changes: a judgment is "
+            "kept and never asked again, so a change rescores nothing."
+        ),
+    )
+    # ---- what a score reads as ----
+    level_bounds: tuple[float, ...] = Field(
+        default=DEFAULT_LEVEL_BOUNDS,
+        min_length=LEVELS - 1,
+        max_length=LEVELS - 1,
+        description=(
+            "Where the five levels part: a score below the first bound is level 1, below the second level 2, "
+            "and so on; at or above the last, level 5. Four bounds, each above the one before, from 0 to 1."
+        ),
+    )
+    level_names: tuple[LevelName, ...] = Field(
+        default=DEFAULT_LEVEL_NAMES,
+        min_length=LEVELS,
+        max_length=LEVELS,
+        description="The five levels' names, level 1 (the least slop) first. Each one line, each named once.",
+    )
+    # ---- who is not a person ----
+    bots: tuple[Identity, ...] = Field(
+        default=(),
+        max_length=MAX_IDENTITIES,
+        description=(
+            "The owner's own bots, as commit names, addresses or forge logins matched whole without regard to "
+            "case: their commits add lines but no attention, and as a co-author they count as an AI agent does. "
+            "Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) "
+            "and embry0's own commit identities. Was the organization's slop_meter_bots."
+        ),
+    )
+    ai_agents: tuple[Identity, ...] = Field(
+        default=(),
+        max_length=MAX_IDENTITIES,
+        description=(
+            "AI coding agents beyond the known ones, as the start of their commit address (aider@), matched "
+            "without regard to case: a commit one authors adds lines but no attention, and one it co-authors "
+            "counts ai_coauthor_share of its author's hours."
+        ),
+    )
+
+    @field_validator("weights")
+    @classmethod
+    def _weights(cls, value: dict[str, float]) -> dict[str, float]:
+        for position, (glob, weight) in enumerate(value.items(), start=1):
+            try:
+                check_glob(glob)
+            except ValueError as exc:
+                raise ValueError(f"glob {position}: {exc}") from None
+            if not 0 <= weight <= 10:
+                raise ValueError(f"glob {position}: a weight is from 0 to 10")
+        return value
+
+    @field_validator("excluded_dirs", "test_dirs")
+    @classmethod
+    def _dirs(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        return _each(value, check_dir_name, "directory")
+
+    @field_validator("test_files")
+    @classmethod
+    def _test_files(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        return _each(value, check_glob, "glob")
+
+    @field_validator("test_marks")
+    @classmethod
+    def _test_marks(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        return _each(value, check_mark, "mark")
+
+    @field_validator("coauthor_shares")
+    @classmethod
+    def _shares(cls, value: tuple[float, ...]) -> tuple[float, ...]:
+        if any(not 0 <= share <= 1 for share in value):
+            raise ValueError("each share is from 0 to 1")
+        return value
+
+    @field_validator("level_bounds")
+    @classmethod
+    def _bounds(cls, value: tuple[float, ...]) -> tuple[float, ...]:
+        if any(not 0 < bound <= 1 for bound in value):
+            raise ValueError("each bound is above 0 and at most 1, as a score is")
+        if any(later <= earlier for earlier, later in zip(value, value[1:], strict=False)):
+            raise ValueError("each bound is above the one before it")
+        return value
+
+    @field_validator("level_names")
+    @classmethod
+    def _names(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        for position, name in enumerate(value, start=1):
+            if not name.strip() or name != name.strip():
+                raise ValueError(f"level {position}: write a name, with no blanks around it")
+            try:
+                refuse_unprintable(name, what="a level's name")
+            except ValueError as exc:
+                raise ValueError(f"level {position}: {exc}") from None
+        if len({name.lower() for name in value}) != len(value):
+            raise ValueError("name each level once")
+        return value
+
+    @field_validator("judge_prompt")
+    @classmethod
+    def _prompt(cls, value: str) -> str:
+        if not value.strip():
+            raise ValueError("write what the judge is told, not blanks")
+        if any(
+            unicodedata.category(char) in ("Cf", "Zl", "Zp")
+            or (unicodedata.category(char) == "Cc" and char not in "\n\t")
+            for char in value
+        ):
+            raise ValueError("the prompt is plain text: lines and tabs, no control, format or separator character")
+        return value
+
+    @field_validator("bots")
+    @classmethod
+    def _bots(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        return _each(value, _identity, "bot")
+
+    @field_validator("ai_agents")
+    @classmethod
+    def _ai_agents(cls, value: tuple[str, ...]) -> tuple[str, ...]:
+        return _each(value, _agent, "AI agent")
+
+    @model_validator(mode="after")
+    def _core_ramp(self) -> SlopMeterSettings:
+        if self.core_full_commits <= self.core_min_commits:
+            raise ValueError("core_full_commits is not more than core_min_commits: the ramp needs room to rise")
+        return self
+
+
+def config_version(settings: SlopMeterSettings) -> str:
+    """A digest of every key a score is computed from (all but :data:`NOT_SCORED`), as a repository reads them.
+
+    Stable across processes and releases for the same values: the keys and
+    the entries of ``weights`` are sorted, and every value is written as the
+    model dumps it to JSON. Each score row records it.
+    """
+    values = {key: value for key, value in settings.model_dump(mode="json").items() if key not in NOT_SCORED}
+    text = json.dumps(values, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
+    return hashlib.sha256(text.encode()).hexdigest()[:16]
+
+
+#: The section's keys an organization may set: all but whether the meter runs and how often.
+_ORG_KEYS: Final = frozenset(SlopMeterSettings.model_fields) - {"enabled", "interval_hours"}
+#: What counts as code in one repository's layout.
+_REPO_KEYS: Final = frozenset({"weights", "excluded_dirs", "test_dirs", "test_files", "test_marks"})
+_INTERVAL_VARIABLE: Final = "slop_meter_interval_seconds"
+
+SLOP_METER = Section(
+    name="slop_meter",
+    model=SlopMeterSettings,
+    summary=(
+        "How the Slop-O-Meter weighs a changed line and a person's attention, where its levels fall, which "
+        "identities are bots, and how often and how hard it reads the forge."
+    ),
+    # What counts as code, how fast a team attends to it, where its levels
+    # fall, its judge's guidance and its own bots are an organization's to
+    # say; what counts as code is a repository's too, for its layout. The
+    # forge budget is per credential, which an organization reads with.
+    # Whether the meter runs and how often are the deployment's alone.
+    org_keys=_ORG_KEYS,
+    repo_keys=_REPO_KEYS,
+    merged_keys=frozenset({"weights"}),
+    env={
+        "enabled": EnvImport(_INTERVAL_VARIABLE, enabled_from_env),
+        "interval_hours": EnvImport(_INTERVAL_VARIABLE, interval_from_env),
+        "api_calls_per_tick": "slop_meter_api_calls_per_tick",
+        "rate_reserve": "slop_meter_rate_reserve",
+    },
+)
diff --git a/embry0/storage/migrations/runner.py b/embry0/storage/migrations/runner.py
index a98fa451..9c1eb08b 100644
--- a/embry0/storage/migrations/runner.py
+++ b/embry0/storage/migrations/runner.py
@@ -4165,6 +4165,19 @@ def lit(value: str) -> str:
             '#167: the leader of the job''s template when it was planned; a job led by the context auditor is an audit.';
         """,
     ),
+    (
+        144,
+        "slop-o-meter: each score's configuration version, so a change to what a score is computed from rescores it",
+        # The digest of the slop_meter section's scoring keys as the
+        # repository read them (embry0.settings.sections.slop_meter.config_version,
+        # #169). A row scored before this migration has none (''), which no
+        # digest equals, so the next run records one.
+        """
+        ALTER TABLE slop_meter_scores ADD COLUMN IF NOT EXISTS config_version TEXT NOT NULL DEFAULT '';
+        COMMENT ON COLUMN slop_meter_scores.config_version IS
+            'a digest of the slop_meter settings a score was computed from (#169); empty for a score from before it.';
+        """,
+    ),
 ]
 
 
diff --git a/embry0/storage/repositories/slop_meter.py b/embry0/storage/repositories/slop_meter.py
index c877eac8..4ef4380a 100644
--- a/embry0/storage/repositories/slop_meter.py
+++ b/embry0/storage/repositories/slop_meter.py
@@ -1,4 +1,4 @@
-"""The Slop-O-Meter's rows (migration 121, spec 2026-10-26, slop-o-meter).
+"""The Slop-O-Meter's rows (migrations 121, 122 and 144, spec 2026-10-26, slop-o-meter).
 
 A repository's history as read (commits, forge events, login emails, outlier
 commit judgments), where reading it stands, and what is computed from it: the
@@ -229,8 +229,11 @@ async def judge(self, repo: str, sha: str, *, slop: bool, reason: str, model: st
 
     # ---- what is computed ----
 
-    async def store(self, repo: str, results: Mapping[str, Any], computed_at: datetime) -> None:
-        """Replace the repository's series and scores with ``results`` (area → Meter, '' the repository)."""
+    async def store(
+        self, repo: str, results: Mapping[str, Any], computed_at: datetime, config_version: str = ""
+    ) -> None:
+        """Replace the repository's series and scores with ``results`` (area → Meter, '' the repository), each
+        score recording ``config_version``, the digest of the settings it was computed from (migration 144)."""
         async with self._db.transaction() as conn:
             await conn.execute("DELETE FROM slop_meter_weeks WHERE repo = $1", repo)
             await conn.execute("DELETE FROM slop_meter_scores WHERE repo = $1", repo)
@@ -246,10 +249,11 @@ async def store(self, repo: str, results: Mapping[str, Any], computed_at: dateti
                     weeks,
                 )
             await conn.executemany(
-                "INSERT INTO slop_meter_scores (repo, area, score, level, name, provisional, commits, computed_at) "
-                "VALUES ($1, $2, $3, $4, $5, $6, $7, $8)",
+                "INSERT INTO slop_meter_scores "
+                "(repo, area, score, level, name, provisional, commits, computed_at, config_version) "
+                "VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9)",
                 [
-                    (repo, area, m.score, m.level, m.name, m.provisional, m.commits, computed_at)
+                    (repo, area, m.score, m.level, m.name, m.provisional, m.commits, computed_at, config_version)
                     for area, m in results.items()
                 ],
             )
diff --git a/frontend/src/api/slopMeter.ts b/frontend/src/api/slopMeter.ts
index 0c4fc1db..6ffa66a6 100644
--- a/frontend/src/api/slopMeter.ts
+++ b/frontend/src/api/slopMeter.ts
@@ -5,7 +5,7 @@ import { repoPath } from "./repoPath";
 export interface SlopMeterReading {
   /** Cumulative slop over cumulative attention cost, 0 to 1. */
   score: number;
-  /** 1 Buttered Noodles … 5 Just The Slop. */
+  /** 1 to 5: 1 the least slop. Their names are the settings document's `slop_meter.level_names`. */
   level: number;
   name: string;
   /** A large commit is not judged yet: its lines are left out of the slop until it is. */
@@ -31,7 +31,14 @@ export interface SlopMeter {
   /** The area the series is of; null for the whole repository. */
   area: string | null;
   weeks: SlopMeterWeek[];
-  reading: { commits_read: number; commits_total: number; computed_at: string | null; error: string | null };
+  reading: {
+    commits_read: number;
+    commits_total: number;
+    computed_at: string | null;
+    error: string | null;
+    /** The version of the `slop_meter` settings the repository's score was computed with; null before one (#169). */
+    config_version?: string | null;
+  };
 }
 
 export async function fetchSlopMeter(fullRepo: string, area = ""): Promise<SlopMeter> {
diff --git a/tests/unit/api/test_background_scope_live.py b/tests/unit/api/test_background_scope_live.py
index 23719dec..f59cef52 100644
--- a/tests/unit/api/test_background_scope_live.py
+++ b/tests/unit/api/test_background_scope_live.py
@@ -12,6 +12,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import dataclasses
 import os
 from collections.abc import AsyncIterator, Sequence
@@ -28,7 +29,7 @@
 from embry0.services.leads import Lead
 from embry0.services.scout import ScoutLoop
 from embry0.services.slop_meter.history import Commit
-from embry0.services.slop_meter.loop import SlopMeterLoop, SlopMeterSettings
+from embry0.services.slop_meter.loop import SlopMeterLimits, SlopMeterLoop
 from embry0.services.slop_meter.mirror import GitMirror
 from embry0.storage.database import DatabasePool
 from embry0.storage.repositories.scout import ScoutRunsRepository
@@ -78,10 +79,14 @@ async def app(
         )
     app = create_app(config)
     async with lifespan(app):
-        # With its schedule off, the meter only removes, once, what left its scope: let that finish first.
-        for task in list(app.state.background_tasks):
-            if task.get_coro().__qualname__ == "SlopMeterLoop.start":
-                await task
+        # With the meter off (slop_meter.enabled: false, imported from SLOP_METER_INTERVAL_SECONDS=0), its first
+        # look only removes what left its scope, then it waits five minutes: let that first look finish first.
+        meter: SlopMeterLoop = app.state.slop_meter
+        for _ in range(500):
+            if meter.last_pass is not None:
+                break
+            await asyncio.sleep(0.01)
+        assert meter.last_pass is not None, "the meter's first look ran at its start"
         for owner in ("acme", "globex"):
             await app.state.organizations_repo.register(owner, "github")
         for repo in ("acme/widgets", "acme/gadgets", "globex/gizmos", "globex/tools"):
@@ -234,7 +239,7 @@ async def no_bots(repo: str) -> tuple[str, ...]:
         client_for=no_credential,
         bots=no_bots,
         calls=NoCalls(),  # type: ignore[arg-type]
-        settings=SlopMeterSettings(),
+        limits=SlopMeterLimits(),
         clock=lambda: clock[0],
     )
 
diff --git a/tests/unit/api/test_slop_meter_settings_live.py b/tests/unit/api/test_slop_meter_settings_live.py
new file mode 100644
index 00000000..34df2450
--- /dev/null
+++ b/tests/unit/api/test_slop_meter_settings_live.py
@@ -0,0 +1,270 @@
+"""The Slop-O-Meter's scoring policy is a settings section (#169), on the real app and Postgres.
+
+Through the real lifespan, the real settings store and the meter's real
+store: a weight changed in an organization's layer, as an operator writes it
+(``PATCH /api/v1/config/settings/slop_meter?owner=``), rescores its
+repository on the meter's next look, and the score row records the version
+of the settings it was computed with; undoing the change rescores it back.
+The write paths answer 422 naming every refused key, and an organization's
+``slop_meter_bots`` (#184) moves into its layer. Docker is stubbed; nothing
+runs git: the history comes from a fake mirror.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import json
+import os
+from collections.abc import AsyncIterator
+from datetime import UTC, datetime, timedelta
+from pathlib import Path
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+from httpx import ASGITransport, AsyncClient
+
+from embry0.api.app import create_app, lifespan
+from embry0.config import Embry0Config
+from embry0.services.slop_meter import loop as loop_module
+from embry0.services.slop_meter.loop import SlopMeterLoop
+from embry0.storage.database import DatabasePool
+from tests.unit.metrics.test_lifespan_wiring import stub_container_runtime  # noqa: F401 - a fixture
+from tests.unit.services.slop_meter import test_loop as fakes
+
+pytestmark = pytest.mark.requires_postgres
+
+URL = "/api/v1/config/settings"
+HEADERS = {"X-Requested-With": "XMLHttpRequest"}
+REPO = "acme/widgets"
+NOW = datetime(2026, 10, 31, 12, 0, tzinfo=UTC)
+
+
+def _config(db: DatabasePool, tmp_path: Path) -> Embry0Config:
+    with patch.dict(os.environ, {}, clear=True):
+        return Embry0Config(  # type: ignore[call-arg]
+            _env_file=None,
+            database_url=db._url,  # noqa: SLF001
+            auth_dev_mode=True,
+            webhook_dev_mode=True,
+            api_key="",
+            watcher_enabled=False,
+            volume_reaper_enabled=False,
+            linear_reconcile_mode="off",
+            telegram_bot_token="",
+            xai_proxy_enabled=False,
+            auth_proxy_enabled=False,
+            context_proxy_enabled=False,
+            leads_enabled=False,
+            # The production meter's first look only removes, then it waits: the tests run their own.
+            slop_meter_interval_seconds=0,
+            slop_meter_data_path=str(tmp_path / "slop-meter"),
+        )
+
+
+async def _started(app: Any) -> None:
+    meter: SlopMeterLoop = app.state.slop_meter
+    if not hasattr(meter, "last_pass"):
+        pytest.fail("the meter has no schedule that looks at the settings: a change waits for a restart")
+    for _ in range(500):
+        if meter.last_pass is not None:
+            return
+        await asyncio.sleep(0.01)
+    pytest.fail("the production meter's first look never ran")
+
+
+@pytest.fixture
+async def app(
+    db_with_migrations: DatabasePool,
+    stub_container_runtime: Any,  # noqa: F811
+    tmp_path: Path,
+) -> AsyncIterator[Any]:
+    """The real app through its real lifespan, with ``acme`` registered and ``acme/widgets`` enrolled."""
+    app = create_app(_config(db_with_migrations, tmp_path))
+    async with lifespan(app):
+        await _started(app)
+        await app.state.organizations_repo.register("acme", "github")
+        await app.state.repos_repo.register(REPO, forge="github")
+        await _put(app, "background:\n  slop_meter: true\n", owner="acme")
+        await _put(app, "slop_meter:\n  enabled: true\n")
+        yield app
+
+
+async def _call(app: Any, method: str, url: str, **kwargs: Any) -> Any:
+    async with AsyncClient(transport=ASGITransport(app=app), base_url="http://test", headers=HEADERS) as client:
+        return await client.request(method, url, **kwargs)
+
+
+async def _put(app: Any, text: str, **params: str) -> None:
+    resp = await _call(app, "PUT", URL, content=text, headers={"Content-Type": "application/yaml"}, params=params)
+    assert resp.status_code == 200, f"the settings document took {text!r} at {params or 'the deployment'}: {resp.text}"
+
+
+async def _patch(app: Any, keys: dict[str, Any], **params: str) -> Any:
+    return await _call(
+        app,
+        "PATCH",
+        f"{URL}/slop_meter",
+        content=json.dumps(keys),
+        headers={"Content-Type": "application/json"},
+        params=params,
+    )
+
+
+class _Mirror(fakes.FakeMirror):
+    """A fake mirror that also lists what it holds on disk, for the prune each tick runs first: nothing."""
+
+    async def held(self) -> list[str]:
+        return []
+
+
+def _meter(app: Any, clock: list[datetime]) -> SlopMeterLoop:
+    """The production meter's readers (the registry and the settings documents), its bots reader and its real
+    store, with a fake mirror holding a history of SQL and Python, and no forge client: commits only."""
+    production: SlopMeterLoop = app.state.slop_meter
+    order = [f"q{i:03d}" for i in range(30)]
+    records = {
+        sha: fakes._record(
+            sha, NOW - timedelta(days=60) + timedelta(hours=5 * i), [("db/q.sql", 400, 0), ("a.py", 9, 0)]
+        )
+        for i, sha in enumerate(order)
+    }
+
+    async def token_for(repo: str) -> tuple[str, str, str]:
+        return ("github", "token-1", "")
+
+    async def no_client(repo: str) -> None:
+        return None
+
+    pruner = production._pruner  # noqa: SLF001
+    limits = getattr(loop_module, "SlopMeterLimits", None)
+    if limits is None:
+        pytest.fail("the meter's loop takes no process limits apart from the settings document's slop_meter section")
+    return SlopMeterLoop(
+        repos=production._repos,  # noqa: SLF001 - the production readers are what this test pins
+        read=production._read,  # noqa: SLF001
+        store=app.state.slop_meter_repo,
+        mirror=_Mirror(records, order),
+        exits=pruner.exits,
+        audit=pruner.audit,
+        token_for=token_for,
+        client_for=no_client,
+        bots=production._bots,  # noqa: SLF001
+        calls=fakes.FakeCalls(),
+        limits=limits(commits_per_tick=100),
+        clock=lambda: clock[0],
+    )
+
+
+async def _score(db: DatabasePool) -> tuple[float, str]:
+    row = await db.fetchrow("SELECT score, config_version FROM slop_meter_scores WHERE repo = $1 AND area = ''", REPO)
+    assert row is not None, "the meter stored no score for the repository"
+    return float(row["score"]), str(row["config_version"])
+
+
+async def _effective_version(app: Any) -> str:
+    from embry0.settings.sections.slop_meter import SLOP_METER, config_version
+
+    snapshot = await app.state.settings.snapshot()
+    return config_version(snapshot.scoped(SLOP_METER).repo(REPO))
+
+
+async def test_a_weight_changed_in_the_document_rescores_on_the_next_run_and_records_the_version(
+    app: Any, db_with_migrations: DatabasePool
+) -> None:
+    db = db_with_migrations
+    clock = [NOW]
+    loop = _meter(app, clock)
+    assert await loop.scheduled() is True, "the first look reads and scores the enrolled repository"
+    first_score, first_version = await _score(db)
+    assert first_version == await _effective_version(app) != "", (
+        "the score records the version of the settings acme/widgets reads"
+    )
+
+    resp = await _patch(app, {"weights": {"*.sql": 0.1}}, owner="acme")
+    assert resp.status_code == 200, resp.text
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is True, "a weight changed: the next look rescores, without waiting for the day"
+    second_score, second_version = await _score(db)
+    assert second_version == await _effective_version(app) != first_version, (
+        f"the rescored row records the new version: {first_version} → {second_version}"
+    )
+    assert second_score != first_score, f"SQL weighing a tenth changes the score: {first_score} → {second_score}"
+    reading = await _call(app, "GET", f"/api/v1/repos/{REPO}/-/slop-meter")
+    assert reading.status_code == 200 and reading.json()["reading"]["config_version"] == second_version
+
+    revisions = await _call(app, "GET", f"{URL}/revisions", params={"owner": "acme"})
+    newest = revisions.json()["revisions"][0]
+    undo = await _call(app, "POST", f"{URL}/revisions/{newest['id']}/undo")
+    assert undo.status_code == 200, f"the change has history with undo: {undo.text}"
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is True, "undoing it is a change too"
+    assert await _score(db) == (first_score, first_version), "and scores as before, recording the first version"
+
+
+async def test_a_write_names_every_refused_key_and_a_repository_may_set_only_its_layout(app: Any) -> None:
+    resp = await _patch(app, {"weights": {"*.PY": 1}, "level_bounds": [0.5, 0.4, 0.6, 0.8], "bots": ["x", "X"]})
+    assert resp.status_code == 422, resp.text
+    named = {tuple(problem["loc"])[-1] for problem in resp.json()["detail"]}
+    assert {"weights", "level_bounds", "bots"} <= named, f"422 names every refused key: {resp.json()['detail']}"
+    assert (await _patch(app, {"weights": {"generated/**": 0}}, repo=REPO)).status_code == 200
+    refused = await _patch(app, {"lines_per_hour": 10}, repo=REPO)
+    assert refused.status_code == 422 and "lines_per_hour" in refused.text, "a team's pace is its organization's"
+
+    document = (await _call(app, "GET", URL, params={"repo": REPO})).json()
+    assert "slop_meter" in document["sections"], "the Policy tab lists the section, as it lists every one"
+    assert sorted(document["settable"]["slop_meter"]) == [
+        "excluded_dirs",
+        "test_dirs",
+        "test_files",
+        "test_marks",
+        "weights",
+    ], "and the keys a repository's layer may set"
+    effective = (await _call(app, "GET", f"{URL}/effective", params={"repo": REPO})).json()
+    [section] = [s for s in effective["sections"] if s["name"] == "slop_meter"]
+    weights = next(k for k in section["keys"] if k["key"] == "weights")
+    sources = {e["entry"]: e["source"] for e in weights["entries"]}
+    assert sources["generated/**"] == "repository" and sources["*.py"] == "default", (
+        f"the values in effect show each glob with the document it comes from: {weights}"
+    )
+
+
+async def test_an_organization_s_bots_move_into_its_layer(app: Any, db_with_migrations: DatabasePool) -> None:
+    resp = await _call(app, "PATCH", "/api/v1/orgs/acme", json={"settings": {"slop_meter_bots": [" release-bot "]}})
+    assert resp.status_code == 200, resp.text
+    assert [note["moved_to"] for note in resp.json()["deprecated"]] == ["slop_meter.bots"], resp.json()
+    layer = await _call(app, "GET", URL, params={"owner": "acme"})
+    assert layer.json()["data"]["slop_meter"]["bots"] == ["release-bot"], "written into acme's layer"
+    assert "slop_meter_bots" not in resp.json()["settings"], "and no longer shown as the organization's own"
+
+    # An owner whose row still lists bots its layer never imported (registered and written after the start's
+    # copy) is read from its row, and copied into its layer by the budget policy's retry.
+    await app.state.organizations_repo.register("globex", "github")
+    await db_with_migrations.execute(
+        "UPDATE organizations SET settings = '{\"slop_meter_bots\": [\"ci-bot\"]}'::jsonb WHERE owner = 'globex'"
+    )
+    read = await app.state.slop_meter._bots("globex/tools")  # noqa: SLF001 - the production bots reader
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    snapshot = await app.state.settings.snapshot()
+    listed = set(read) | set(snapshot.scoped(SLOP_METER).repo("globex/tools").bots)
+    assert "ci-bot" in listed, f"the owner's own bots count, from its row or its layer: {read}, {listed}"
+
+
+async def test_the_first_start_copies_each_organization_s_bots_into_its_layer(
+    db_with_migrations: DatabasePool,
+    stub_container_runtime: Any,  # noqa: F811
+    tmp_path: Path,
+) -> None:
+    db = db_with_migrations
+    await db.execute(
+        "INSERT INTO organizations (owner, forge, settings) VALUES ('acme', 'github', $1::jsonb)",
+        {"slop_meter_bots": ["release-bot", "Release-Bot", " ", "ci@acme.example"]},
+    )
+    app = create_app(_config(db, tmp_path))
+    async with lifespan(app):
+        await _started(app)
+        layer = await _call(app, "GET", URL, params={"owner": "acme"})
+    assert layer.json()["data"].get("slop_meter", {}).get("bots") == ["release-bot", "ci@acme.example"], (
+        f"the start copies the owner's bots into its layer, each once: {layer.json()['data']}"
+    )
diff --git a/tests/unit/api/v1/test_organization_register_settings.py b/tests/unit/api/v1/test_organization_register_settings.py
index e192f72e..549e8907 100644
--- a/tests/unit/api/v1/test_organization_register_settings.py
+++ b/tests/unit/api/v1/test_organization_register_settings.py
@@ -97,16 +97,12 @@ async def test_post_refuses_a_setting_with_the_same_422_as_patch(app: Any, setti
 
 async def test_post_stores_the_settings_as_the_check_writes_them(app: Any) -> None:
     """A setting that moved into the settings document goes to the organization's layer instead
-    (tests/unit/api/test_budget_settings.py)."""
-    body = {
-        "owner": "acme",
-        "probe": False,
-        "settings": {"rediscover_hours": 6, "slop_meter_bots": [" ci-bot ", ""]},
-    }
+    (tests/unit/api/test_budget_settings.py; slop_meter_bots, #169: tests/unit/api/test_slop_meter_settings_live.py)."""
+    body = {"owner": "acme", "probe": False, "settings": {"rediscover_hours": 6, "auto_register": True}}
     async with _client(app) as client:
         resp = await client.post("/api/v1/orgs", json=body)
     assert resp.status_code == 201, resp.text
     stored = app.state.organizations_repo.orgs["acme"].settings
-    assert stored == {"rediscover_hours": 6, "slop_meter_bots": ["ci-bot"]}, (
+    assert stored == {"rediscover_hours": 6, "auto_register": True}, (
         f"POST /orgs stored the body as sent, not as PATCH would: {stored!r}"
     )
diff --git a/tests/unit/api/v1/test_slop_meter_api.py b/tests/unit/api/v1/test_slop_meter_api.py
index cc439234..a2f76294 100644
--- a/tests/unit/api/v1/test_slop_meter_api.py
+++ b/tests/unit/api/v1/test_slop_meter_api.py
@@ -83,7 +83,13 @@ async def test_the_repository_page_reads_its_score_areas_and_weeks(app: Any) ->
         "lines": 9000.0,
         "score": 0.2,
     }
-    assert body["reading"] == {"commits_read": 120, "commits_total": 120, "computed_at": AT.isoformat(), "error": None}
+    assert body["reading"] == {
+        "commits_read": 120,
+        "commits_total": 120,
+        "computed_at": AT.isoformat(),
+        "error": None,
+        "config_version": None,
+    }, "a score from before #169 names no configuration version"
 
 
 async def test_an_area_series_and_the_refusals(app: Any) -> None:
diff --git a/tests/unit/services/slop_meter/test_loop.py b/tests/unit/services/slop_meter/test_loop.py
index b6c1584f..f6272834 100644
--- a/tests/unit/services/slop_meter/test_loop.py
+++ b/tests/unit/services/slop_meter/test_loop.py
@@ -16,10 +16,11 @@
 from embry0.services.slop_meter.events import ApiBudget, BudgetSpent, EventReader
 from embry0.services.slop_meter.history import HISTORY_VERSION, Commit
 from embry0.services.slop_meter.judge import parse_judgment, user_prompt
-from embry0.services.slop_meter.loop import MeterRead, SlopMeterLoop, SlopMeterSettings
+from embry0.services.slop_meter.loop import MeterRead, SlopMeterLimits, SlopMeterLoop
 from embry0.services.slop_meter.mirror import GitError, GitMirror, auth_env
 from embry0.services.slop_meter.score import Outlier
 from embry0.settings.sections.background import BackgroundSettings
+from embry0.settings.sections.slop_meter import SlopMeterSettings
 
 START = datetime(2025, 1, 6, 9, 0, tzinfo=UTC)
 REPO = "acme/web"
@@ -58,6 +59,8 @@ def __init__(self) -> None:
         self.login_map: dict[str, str] = {}
         self.judged: dict[tuple[str, str], bool] = {}
         self.stored: dict[str, Any] = {}
+        #: Each repository's configuration version, as its last scoring recorded it.
+        self.versions: dict[str, str] = {}
 
     async def state(self, repo: str) -> dict[str, Any]:
         return dict(self.states.get(repo, {"repo": repo, "commits_read": 0}))
@@ -100,8 +103,9 @@ async def judgments(self, repo: str) -> dict[str, bool]:
     async def judge(self, repo: str, sha: str, *, slop: bool, reason: str, model: str) -> None:
         self.judged[(repo, sha)] = slop
 
-    async def store(self, repo: str, results: dict[str, Any], computed_at: datetime) -> None:
+    async def store(self, repo: str, results: dict[str, Any], computed_at: datetime, config_version: str = "") -> None:
         self.stored[repo] = results
+        self.versions[repo] = config_version
 
 
 async def _no_bots() -> tuple[str, ...]:
@@ -140,12 +144,30 @@ async def no_audit(*, action: str, details: dict[str, Any]) -> None:
     return None
 
 
-def _read(model: str = "") -> Any:
-    """A tick's read with every listed repository enrolled and its outliers judged on ``model``. Not settled,
-    so nothing is removed: what the meter removes is tested in test_prune.py."""
+class _Meter:
+    """The ``slop_meter`` section, the same for every repository: the defaults with ``values`` over them."""
+
+    def __init__(self, **values: Any) -> None:
+        self.values = SlopMeterSettings(**values)
+
+    def deployment(self) -> SlopMeterSettings:
+        return self.values
+
+    def repo(self, repo: str | None) -> SlopMeterSettings:
+        return self.values
+
+
+def _read(model: str = "", **meter: Any) -> Any:
+    """A tick's read with every listed repository enrolled, its outliers judged on ``model`` and the
+    ``slop_meter`` section's ``meter`` keys over its defaults. Not settled, so nothing is removed: what the
+    meter removes is tested in test_prune.py."""
 
     async def read() -> MeterRead:
-        return MeterRead(models=lambda repo: model, enrollment=Enrollment(_EveryRepository(), frozenset()))
+        return MeterRead(
+            models=lambda repo: model,
+            enrollment=Enrollment(_EveryRepository(), frozenset()),
+            meter=_Meter(**meter),
+        )
 
     return read
 
@@ -194,7 +216,7 @@ async def client_for(repo: str) -> Any:
         client_for=client_for,
         bots=bots,
         calls=calls if calls is not None else FakeCalls(),
-        settings=SlopMeterSettings(commits_per_tick=per_tick),
+        limits=SlopMeterLimits(commits_per_tick=per_tick),
         clock=lambda: START + timedelta(days=60),
     )
 
@@ -296,7 +318,7 @@ async def test_an_outlier_is_judged_by_the_model_and_kept(monkeypatch: pytest.Mo
     store = FakeStore()
     asked: list[str] = []
 
-    async def judge(repo: str, outlier: Outlier, ep: Any, client: Any, calls: Any) -> tuple[bool, str]:
+    async def judge(repo: str, outlier: Outlier, ep: Any, client: Any, calls: Any, **_: Any) -> tuple[bool, str]:
         asked.append(outlier.commit.sha)
         return False, "a vendored parser"
 
@@ -479,14 +501,14 @@ async def client_for(repo: str) -> Any:
         repos=repos,
         exits=NoExits(),
         audit=no_audit,
-        read=_read(),
+        read=_read(api_calls_per_tick=16, rate_reserve=0),
         store=store,
         mirror=mirror,
         token_for=token_for,
         client_for=client_for,
         bots=lambda repo: _no_bots(),
         calls=FakeCalls(),
-        settings=SlopMeterSettings(commits_per_tick=10, event_pages=100, api_calls_per_tick=16, rate_reserve=0),
+        limits=SlopMeterLimits(commits_per_tick=10, event_pages=100),
         clock=lambda: START + timedelta(days=60),
     )
     assert await loop.tick() is True, "the big repository still has comments to read"
@@ -594,19 +616,20 @@ async def get(self, job_id: str) -> dict[str, Any]:
     assert await job_meter({"configurable": {}}, state) is None
 
 
-def test_the_loop_module_names_its_settings_from_config() -> None:
+def test_the_loop_module_names_its_limits_from_config() -> None:
     class Config:
-        slop_meter_interval_seconds = 0
+        slop_meter_catchup_seconds = 60
         slop_meter_commits_per_tick = 7
 
-    settings = loop_mod.slop_meter_settings(Config())
-    assert settings.interval_seconds == 0 and settings.commits_per_tick == 7 and settings.judgments_per_tick == 5
+    limits = loop_mod.slop_meter_limits(Config())
+    assert limits.catchup_seconds == 60 and limits.commits_per_tick == 7 and limits.judgments_per_tick == 5
 
 
 @pytest.mark.asyncio
 async def test_a_repositorys_bots_are_embry0s_authors_there_and_the_owners_list() -> None:
-    """#184: production's ``bots`` reads the repository's preferred author, the owner's credential's
-    author and the owner's ``slop_meter_bots``; a missing source adds nothing."""
+    """#184: production's ``bots`` reads the repository's preferred author and the owner's credential's author,
+    and, until its layer imported them (#169), the ``slop_meter_bots`` the owner's row still lists; a missing
+    source adds nothing."""
     from types import SimpleNamespace
 
     class Store:
@@ -616,12 +639,23 @@ def __init__(self, rows: dict[str, Any]) -> None:
         async def get(self, key: str) -> Any:
             return self.rows.get(key)
 
+    asked: list[tuple[str, str]] = []
+
+    async def moved(section: str, owner: str, settings: Any) -> dict[str, Any]:
+        asked.append((section, owner))
+        return {"bots": list(settings.get("slop_meter_bots") or [])}
+
     prefs = Store({REPO: {"git_author_email": "agent@acme.example"}})
-    org = SimpleNamespace(credential_id="cred-1", settings={"slop_meter_bots": ["release-bot"]})
+    org = SimpleNamespace(owner="acme", credential_id="cred-1", settings={"slop_meter_bots": ["release-bot"]})
     orgs = Store({REPO.split("/")[0]: org})
     credentials = Store({"cred-1": {"git_author_email": "bot@acme.example"}})
-    got = await loop_mod.repo_bots(REPO, prefs=prefs, orgs=orgs, credentials=credentials)
+    got = await loop_mod.repo_bots(REPO, prefs=prefs, orgs=orgs, credentials=credentials, moved=moved)
     assert got == ["agent@acme.example", "bot@acme.example", "release-bot"]
+    assert asked == [("slop_meter", "acme")], "the owner's row is read through the moved-settings reader"
+    imported = await loop_mod.repo_bots(REPO, prefs=prefs, orgs=orgs, credentials=credentials)
+    assert imported == ["agent@acme.example", "bot@acme.example"], (
+        "without the reader the row is not read: the layer's slop_meter.bots are the section's, read when scored"
+    )
     nothing = await loop_mod.repo_bots(REPO, prefs=Store({}), orgs=Store({}), credentials=Store({}))
     assert nothing == []
 
@@ -650,14 +684,14 @@ async def no_bots(repo: str) -> tuple[str, ...]:
         repos=repos,
         exits=NoExits(),
         audit=no_audit,
-        read=_read(),
+        read=_read(api_calls_per_tick=8, rate_reserve=100),
         store=store,
         mirror=FakeMirror(records, order),
         token_for=token_for,
         client_for=client_for,
         bots=no_bots,
         calls=FakeCalls(),
-        settings=SlopMeterSettings(commits_per_tick=10, event_pages=100, api_calls_per_tick=8, rate_reserve=100),
+        limits=SlopMeterLimits(commits_per_tick=10, event_pages=100),
         clock=lambda: START + timedelta(days=60),
     )
     assert await loop.tick() is True
diff --git a/tests/unit/services/slop_meter/test_loop_settings.py b/tests/unit/services/slop_meter/test_loop_settings.py
new file mode 100644
index 00000000..1c687213
--- /dev/null
+++ b/tests/unit/services/slop_meter/test_loop_settings.py
@@ -0,0 +1,277 @@
+"""The meter's loop reads the ``slop_meter`` section every look (#169): a change applies with no restart.
+
+On the fakes of test_loop.py: no git, no network, no database. Each score
+records the configuration version its repository read; a change to what a
+score is computed from rescores at the next look instead of at the next
+interval; ``enabled`` and ``interval_hours`` pace the schedule; each
+organization's forge budget applies to the credential it reads with; and the
+section's bots, AI agents and judge guidance reach the scoring.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from datetime import datetime, timedelta
+from typing import Any
+
+import pytest
+
+from embry0.services.background_scope import Enrollment, Registered
+from embry0.services.slop_meter import loop as loop_mod
+from embry0.services.slop_meter.loop import MeterRead, SlopMeterLoop
+from embry0.settings.sections import CATALOG
+from tests.unit.services.slop_meter import test_loop as fakes
+
+REPO = fakes.REPO
+NOW = fakes.START + timedelta(days=60)
+
+
+def _settings(values: Mapping[str, Any]) -> Any:
+    """The section as a repository reads it from a document writing ``values`` (weights over the defaults)."""
+    from embry0.settings.store import build_snapshot
+
+    section = CATALOG.get("slop_meter")
+    if section is None:
+        pytest.fail("the settings document has no slop_meter section: the meter reads no settings")
+    rows = [{"scope": "deployment", "data": {"slop_meter": dict(values)}, "generation": 1, "updated_at": None}]
+    return build_snapshot(CATALOG, rows, token=(), log=False).scoped(section).repo(REPO)
+
+
+class Section:
+    """The ``slop_meter`` section a test changes between looks: the deployment's values, and per owner."""
+
+    def __init__(self, values: Mapping[str, Any] | None = None, **owners: Mapping[str, Any]) -> None:
+        self.values = dict(values or {})
+        self.owners = {owner: dict(v) for owner, v in owners.items()}
+
+    def deployment(self) -> Any:
+        return _settings(self.values)
+
+    def repo(self, repo: str | None) -> Any:
+        owner = (repo or "").split("/", 1)[0]
+        return _settings({**self.values, **self.owners.get(owner, {})})
+
+
+def _reader(section: Section, model: str = "") -> Any:
+    async def read() -> MeterRead:
+        return MeterRead(
+            models=lambda repo: model,
+            enrollment=Enrollment(fakes._EveryRepository(), frozenset()),
+            meter=section,
+        )
+
+    return read
+
+
+def _loop(
+    section: Section,
+    store: fakes.FakeStore,
+    mirror: fakes.FakeMirror,
+    clock: list[datetime],
+    *,
+    repos: tuple[str, ...] = (REPO,),
+    tokens: Mapping[str, str] | None = None,
+    forges: Mapping[str, Any] | None = None,
+    model: str = "",
+    calls: Any = None,
+) -> SlopMeterLoop:
+    _settings({})  # fails with its own message on a tree with no slop_meter section
+
+    async def registered() -> Registered:
+        return Registered(active=repos)
+
+    async def token_for(repo: str) -> tuple[str, str, str]:
+        return ("github", (tokens or {}).get(repo, "token-1"), "")
+
+    async def client_for(repo: str) -> Any:
+        return (forges or {}).get(repo)
+
+    async def bots(repo: str) -> tuple[str, ...]:
+        return ()
+
+    return SlopMeterLoop(
+        repos=registered,
+        exits=fakes.NoExits(),
+        audit=fakes.no_audit,
+        read=_reader(section, model),
+        store=store,
+        mirror=mirror,
+        token_for=token_for,
+        client_for=client_for,
+        bots=bots,
+        calls=calls if calls is not None else fakes.FakeCalls(),
+        limits=loop_mod.SlopMeterLimits(commits_per_tick=500, event_pages=100),
+        clock=lambda: clock[0],
+    )
+
+
+def _sql_history() -> tuple[dict[str, str], list[str]]:
+    order = [f"q{i:03d}" for i in range(30)]
+    records = {
+        sha: fakes._record(sha, fakes.START + timedelta(hours=5 * i), [("db/q.sql", 400, 0), ("src/a.py", 10, 0)])
+        for i, sha in enumerate(order)
+    }
+    return records, order
+
+
+def _version(values: Mapping[str, Any]) -> str:
+    from embry0.settings.sections.slop_meter import config_version
+
+    return config_version(_settings(values))
+
+
+async def test_a_score_records_the_configuration_version_of_its_repository_s_settings() -> None:
+    records, order = _sql_history()
+    store = fakes.FakeStore()
+    loop = _loop(Section({"weights": {"*.sql": 1.0}}), store, fakes.FakeMirror(records, order), [NOW])
+    assert await loop.tick() is False
+    assert store.versions[REPO] == _version({"weights": {"*.sql": 1.0}}) != _version({}), (
+        f"the score records the version of the settings it was computed with: {store.versions}"
+    )
+
+
+async def test_a_changed_weight_rescores_at_the_next_look_and_records_the_new_version() -> None:
+    records, order = _sql_history()
+    store, clock = fakes.FakeStore(), [NOW]
+    section = Section()
+    loop = _loop(section, store, fakes.FakeMirror(records, order), clock)
+    assert await loop.scheduled() is True, "the first look runs at once"
+    before = store.stored[REPO][""]
+    assert store.versions[REPO] == _version({})
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is False, "nothing changed and the day has not passed: no run"
+    section.values = {"weights": {"*.sql": 0.0}}
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is True, "a weight changed: the next look rescores, not tomorrow's run"
+    after = store.stored[REPO][""]
+    assert store.versions[REPO] == _version({"weights": {"*.sql": 0.0}}), "and records the new version"
+    assert sum(w.cost for w in after.weeks) < sum(w.cost for w in before.weeks), (
+        "SQL weighing nothing lowers the attention cost the score is computed from"
+    )
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is False, "once rescored, the next look waits for the interval again"
+    assert 0 < loop.wait_seconds() <= loop_mod.LOOK_SECONDS
+
+
+async def test_a_key_no_score_is_computed_from_runs_nothing_early() -> None:
+    records, order = _sql_history()
+    store, clock = fakes.FakeStore(), [NOW]
+    section = Section()
+    loop = _loop(section, store, fakes.FakeMirror(records, order), clock)
+    await loop.scheduled()
+    section.values = {"api_calls_per_tick": 10, "judge_prompt": "Judge it."}
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is False, "the forge budget and the judge's guidance rescore nothing"
+
+
+async def test_off_reads_nothing_and_turned_on_it_reads_at_the_next_look() -> None:
+    records, order = _sql_history()
+    store, mirror, clock = fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW]
+    section = Section({"enabled": False})
+    loop = _loop(section, store, mirror, clock)
+    assert await loop.scheduled() is True, "off, the first look still runs: it removes what left the scope"
+    assert mirror.synced == [] and store.stored == {}, "and reads and scores nothing"
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is False
+    section.values = {}
+    clock[0] += timedelta(minutes=5)
+    assert await loop.scheduled() is True, "turned on, the next look reads, not a day after the last removal"
+    assert mirror.synced == [(REPO, "github")] and REPO in store.stored
+
+
+async def test_the_interval_is_the_section_s() -> None:
+    records, order = _sql_history()
+    store, clock = fakes.FakeStore(), [NOW]
+    loop = _loop(Section({"interval_hours": 1}), store, fakes.FakeMirror(records, order), clock)
+    await loop.scheduled()
+    clock[0] += timedelta(minutes=59)
+    assert await loop.scheduled() is False and loop.wait_seconds() == pytest.approx(60), "due in a minute"
+    clock[0] += timedelta(minutes=2)
+    assert await loop.scheduled() is True, "an hour after the last run ended"
+
+
+async def test_each_organization_s_forge_budget_applies_to_its_credential_and_a_shared_one_takes_the_strictest() -> (
+    None
+):
+    acme, globex = "acme/app", "globex/app"
+    records, order = fakes._history(2)
+    section = Section({}, acme={"api_calls_per_tick": 3, "rate_reserve": 0}, globex={"api_calls_per_tick": 12})
+
+    def forges() -> dict[str, Any]:
+        return {name: fakes.FakeForge(comment_pages=50, repo=name) for name in (acme, globex)}
+
+    apart = forges()
+    tokens = {acme: "token-acme", globex: "token-globex"}
+    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], repos=(acme, globex))
+    loop._client_for = _clients(apart)  # noqa: SLF001
+    loop._token_for = _tokens(tokens)  # noqa: SLF001
+    await loop.tick()
+    assert (len(apart[acme].calls), len(apart[globex].calls)) == (3, 12), (
+        "each organization's credential has the calls its organization allows: "
+        f"{len(apart[acme].calls)} and {len(apart[globex].calls)}"
+    )
+    shared = forges()
+    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], repos=(acme, globex))
+    loop._client_for = _clients(shared)  # noqa: SLF001
+    await loop.tick()
+    assert len(shared[acme].calls) + len(shared[globex].calls) == 3, (
+        "read with one credential, the two share the fewer calls either organization allows"
+    )
+
+
+def _clients(forges: Mapping[str, Any]) -> Any:
+    async def client_for(repo: str) -> Any:
+        return forges.get(repo)
+
+    return client_for
+
+
+def _tokens(tokens: Mapping[str, str]) -> Any:
+    async def token_for(repo: str) -> tuple[str, str, str]:
+        return ("github", tokens[repo], "")
+
+    return token_for
+
+
+async def test_the_section_s_bots_and_ai_agents_are_bots_when_scored(monkeypatch: pytest.MonkeyPatch) -> None:
+    def record(sha: str, hours: int, email: str, body: str = "Work") -> str:
+        at = fakes.START + timedelta(hours=hours)
+        return f"\x1e{sha}\x1f{at.isoformat()}\x1fSomeone\x1f{email}\x1f{body}\n\x1f\n20\t0\tsrc/a.py\n"
+
+    records = {
+        "c0": record("c0", 0, "dev@example.com", "x\n\nCo-authored-by: Helper <helper@tools.example>"),
+        "c1": record("c1", 3, "release@acme.example"),
+        "c2": record("c2", 6, "helper@tools.example"),
+    }
+    seen: list[Any] = []
+    real = loop_mod.compute
+
+    def spy(inputs: Any) -> Any:
+        seen.append(inputs)
+        return real(inputs)
+
+    monkeypatch.setattr(loop_mod, "compute", spy)
+    section = Section({}, acme={"bots": ["Release@Acme.example"], "ai_agents": ["helper@"]})
+    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, ["c0", "c1", "c2"]), [NOW], repos=(REPO,))
+    await loop.tick()
+    [inputs] = seen
+    assert {c.sha for c in inputs.commits if c.bot} == {"c1", "c2"}, "the owner's bot and the AI agent author"
+    assert inputs.commits[0].ai_coauthor and inputs.commits[0].coauthors == (), "the agent co-wrote, not a person"
+    assert inputs.settings.bots == ("Release@Acme.example",), "the repository is scored with its owner's section"
+
+
+async def test_the_judge_hears_the_repository_s_guidance(monkeypatch: pytest.MonkeyPatch) -> None:
+    records, order = fakes._history(40)
+    records["big"] = fakes._record("big", fakes.START + timedelta(days=200), [("src/drop.py", 9_000, 0)])
+    order.append("big")
+    heard: list[str] = []
+
+    async def judge(repo: str, outlier: Any, ep: Any, client: Any, calls: Any, *, guidance: str) -> tuple[bool, str]:
+        heard.append(guidance)
+        return False, "a vendored parser"
+
+    monkeypatch.setattr("embry0.services.slop_meter.judge.judge", judge)
+    section = Section({}, acme={"judge_prompt": "Imports under third_party are never slop."})
+    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], model="custom/local")
+    await loop.tick()
+    assert heard == ["Imports under third_party are never slop."], f"the owner's guidance reached the judge: {heard}"
diff --git a/tests/unit/services/slop_meter/test_mirror_subgroups.py b/tests/unit/services/slop_meter/test_mirror_subgroups.py
index 789d44c8..2cbb27e8 100644
--- a/tests/unit/services/slop_meter/test_mirror_subgroups.py
+++ b/tests/unit/services/slop_meter/test_mirror_subgroups.py
@@ -26,7 +26,7 @@
 from embry0.api.schemas.repo_path import REPO_PATH_PATTERN
 from embry0.services.background_scope import Registered
 from embry0.services.slop_meter import mirror as mirror_mod
-from embry0.services.slop_meter.loop import SlopMeterLoop, SlopMeterSettings
+from embry0.services.slop_meter.loop import SlopMeterLimits, SlopMeterLoop
 from embry0.services.slop_meter.mirror import GitError, GitMirror, MirrorRefused
 from tests.unit.services.slop_meter.test_loop import FakeCalls, FakeStore, NoExits, _read, no_audit
 from tests.unit.services.slop_meter.test_prune import GRACE, NOW, Audit, Exits, Store, _pruner
@@ -323,7 +323,7 @@ async def no_bots(repo: str) -> tuple[str, ...]:
         client_for=nothing,
         bots=no_bots,
         calls=FakeCalls(),
-        settings=SlopMeterSettings(commits_per_tick=100),
+        limits=SlopMeterLimits(commits_per_tick=100),
         clock=lambda: datetime(2025, 3, 1, tzinfo=UTC),
     )
     assert await loop.tick() is False, "every history is read in one tick"
diff --git a/tests/unit/services/slop_meter/test_prune.py b/tests/unit/services/slop_meter/test_prune.py
index 3f38a464..bf393bff 100644
--- a/tests/unit/services/slop_meter/test_prune.py
+++ b/tests/unit/services/slop_meter/test_prune.py
@@ -23,7 +23,7 @@
 import pytest
 from structlog.testing import capture_logs
 
-from embry0.services.slop_meter.loop import SlopMeterLoop, SlopMeterSettings
+from embry0.services.slop_meter.loop import SlopMeterLimits, SlopMeterLoop
 from embry0.services.slop_meter.mirror import GitMirror
 from embry0.settings.sections import CATALOG
 from embry0.settings.store import build_snapshot
@@ -632,11 +632,20 @@ async def test_a_mirror_the_guard_refuses_is_left_for_a_person_and_its_rows_go_a
 # ---- the loop: the next tick, once enrollment is settled ----
 
 
-def _snapshot(layers: Mapping[str, Mapping[str, Any]], *, imported: bool, grace_days: int = 7) -> Any:
+def _snapshot(
+    layers: Mapping[str, Mapping[str, Any]],
+    *,
+    imported: bool,
+    grace_days: int = 7,
+    meter: Mapping[str, Any] | None = None,
+) -> Any:
+    deployment: dict[str, Any] = {"background": {"prune_after_days": grace_days}}
+    if meter is not None:
+        deployment["slop_meter"] = dict(meter)
     rows: list[dict[str, Any]] = [
         {
             "scope": "deployment",
-            "data": {"background": {"prune_after_days": grace_days}},
+            "data": deployment,
             "generation": 1,
             "updated_at": None,
             "bootstrapped_keys": ["background.slop_meter"] if imported else [],
@@ -707,7 +716,7 @@ async def no_bots(repo: str) -> tuple[str, ...]:
         client_for=nothing,
         bots=no_bots,
         calls=None,  # type: ignore[arg-type]
-        settings=SlopMeterSettings(),
+        limits=SlopMeterLimits(),
         clock=lambda: now[0],
     )
 
@@ -774,22 +783,23 @@ async def test_a_registry_read_that_comes_back_empty_removes_nothing() -> None:
     )
 
 
-async def test_with_its_schedule_off_the_meter_still_removes_what_left_its_scope_at_start() -> None:
+async def test_with_the_meter_off_it_still_removes_what_left_its_scope_at_its_first_look() -> None:
     documents = Documents(
         _snapshot(
             {"repository:acme/widgets": {"slop_meter": False}, "organization:other": {"slop_meter": True}},
             imported=True,
+            meter={"enabled": False},
         )
     )
     exits = Exits()
     exits.rows[("slop_meter", "acme/widgets")] = NOW - timedelta(days=8)
     store, mirror = Store(["acme/widgets", "other/kit"]), Mirror()
     loop = _meter(documents, store, mirror, ["acme/widgets", "other/kit"], exits=exits)
-    loop._settings = SlopMeterSettings(interval_seconds=0)  # noqa: SLF001 - SLOP_METER_INTERVAL_SECONDS=0
-    await loop.start()
+    assert await loop.scheduled() is True
     assert store.forgotten == ["acme/widgets"] == mirror.removed, (
-        "SLOP_METER_INTERVAL_SECONDS=0 stops the reading, not the removal: the start removes what the meter kept "
-        "of a repository whose week out of its scope has passed"
+        "slop_meter.enabled: false stops the reading, not the removal: the first look removes what the meter "
+        "kept of a repository whose week out of its scope has passed (reading other/kit would have failed: this "
+        "store records no state)"
     )
 
 
diff --git a/tests/unit/services/slop_meter/test_scoring_settings.py b/tests/unit/services/slop_meter/test_scoring_settings.py
new file mode 100644
index 00000000..693e9900
--- /dev/null
+++ b/tests/unit/services/slop_meter/test_scoring_settings.py
@@ -0,0 +1,317 @@
+"""The Slop-O-Meter scores with the ``slop_meter`` section (#169): nothing written scores exactly as before.
+
+Two proofs that the defaults moved without changing a score. A fixture
+history is scored to the bit-for-bit numbers the pre-#169 code produced
+(pinned below, computed on 65cf0eaf with the same builder, which uses only
+APIs that tree has), read with no section, with an empty stored document and
+with a document that writes every key at its default. And the weight of every
+path of a large corpus equals what the pre-#169 rules (copied verbatim below)
+gave it. Then each key is shown to move the score the way its description
+says. No git, no network, no database.
+"""
+
+from __future__ import annotations
+
+import random
+import re
+from dataclasses import replace
+from datetime import UTC, datetime, timedelta
+from itertools import product
+from typing import Any
+
+import pytest
+
+from embry0.services.slop_meter.history import parse_log
+from embry0.services.slop_meter.loop import Inputs, compute
+from embry0.services.slop_meter.score import Event, meters
+from embry0.services.slop_meter.weights import Weigher, type_weight
+from embry0.settings.document import check
+from embry0.settings.sections import CATALOG
+from embry0.settings.store import build_snapshot
+
+START = datetime(2024, 3, 4, 9, 0, tzinfo=UTC)  # a Monday
+REPO = "acme/widgets"
+
+# ---- the fixture history (the builder the golden numbers were computed with) ----
+
+PATHS = (
+    "api/server.py", "api/models.py", "api/db/queries.sql", "api/tests/test_server.py", "api/server_test.go",
+    "web/src/App.tsx", "web/src/app.ts", "web/src/app.test.ts", "web/src/style.css", "web/src/theme.scss",
+    "web/dist/bundle.js", "web/vendor/lib.js", "web/node_modules/x/index.js", "web/types/api.d.ts",
+    "web/src/Button.stories.tsx", "docs/README.md", "package.json", "lib/core.rs", "lib/util.go",
+    "examples/demo.py", "scripts/run.sh", "assets/logo.svg", "web/app.min.js", "web/app.js.map",
+    "gen/schema.pb.go", "legacy/old.py",
+)  # fmt: skip
+AUTHORS = (
+    ("Ana", "ana@example.com"),
+    ("Bo", "bo@example.com"),
+    ("Cy", "cy@example.com"),
+    ("Drive By", "drive@example.com"),
+    ("12345+octo", "12345+octo@users.noreply.github.com"),
+)
+
+
+def _record(sha: str, at: datetime, name: str, email: str, body: str, files: list[tuple[str, int, int]]) -> str:
+    numstat = "\n".join(f"{a}\t{d}\t{p}" for p, a, d in files)
+    return f"\x1e{sha}\x1f{at.isoformat()}\x1f{name}\x1f{email}\x1f{body}\n\x1f\n{numstat}\n"
+
+
+def fixture_inputs() -> Inputs:
+    """240 commits over a year: a core author, drive-bys, a bot, squashes, human and AI co-authors, judged
+    outliers, ignore lists, areas, and forge events."""
+    rng = random.Random(169)
+    text = []
+    at = START
+    for i in range(240):
+        at += timedelta(hours=rng.choice((2, 3, 5, 8, 13, 26, 49)))
+        name, email = AUTHORS[0 if i % 3 == 0 else rng.randrange(len(AUTHORS))]
+        if i % 17 == 5:
+            name, email = "dependabot[bot]", "49699333+dependabot[bot]@users.noreply.github.com"
+        files = [(rng.choice(PATHS), rng.randint(1, 120), rng.randint(0, 60)) for _ in range(rng.randint(1, 5))]
+        body = "Work"
+        if i % 11 == 0:
+            body = "Squash\n\n* one\n* two\n* three\n"
+        if i % 7 == 0:
+            body += "\n\nCo-authored-by: Claude <claude@anthropic.com>"
+        if i % 13 == 0:
+            body += "\n\nCo-authored-by: Bo <bo@example.com>\nCo-authored-by: Cy <cy@example.com>"
+        if i in (0, 1):
+            files = [("api/server.py", 3_000, 0), ("web/src/App.tsx", 2_000, 0)]
+        if i == 120:
+            files = [("legacy/old.py", 8_000, 0), ("web/src/app.ts", 1_500, 10)]
+        if i == 200:
+            files = [("lib/core.rs", 6_000, 100)]
+        text.append(_record(f"c{i:04d}", at, name, email, body, files))
+    commits = parse_log("".join(text))
+    events = []
+    for _ in range(90):
+        when = START + timedelta(days=rng.randint(0, 300), hours=rng.randint(0, 23))
+        login = rng.choice(("ana", "bo", "octo", "renovate[bot]", "stranger"))
+        events.append(Event(login, when, rng.choice(("comment", "review", "review_comment"))))
+    files = {
+        ".prettierignore": "web/dist/\n",
+        ".gitattributes": "gen/** linguist-generated=true\n",
+        ".embry0/areas.yml": "areas:\n  - name: Api\n    paths: [api/**]\n  - name: Web\n    paths: [web/**]\n",
+    }
+    return Inputs(commits, events, {"bo": "bo@example.com"}, {"c0120": True, "c0200": False}, files)
+
+
+#: Per scope: score, level, name, provisional, weeks, and the sums of the weeks' cost, capacity and slop, as the
+#: pre-#169 code (65cf0eaf) computed them from :func:`fixture_inputs`.
+GOLDEN = {
+    "": (0.5719725615148507, 3, "Lasagna", False, 24, 32441.512143782704, 8949.335858490183, 18555.654800294527),
+    "Api": (0.673697461755875, 4, "Sloppy Joe", False, 24, 10120.407362766382, 3753.1871163668848, 6818.092752231182),
+    "Web": (0.7043431761241699, 4, "Sloppy Joe", False, 24, 5503.127229395564, 1958.1180324877657, 3876.090111367875),
+}
+
+
+def _scored(inputs: Inputs) -> dict[str, tuple[Any, ...]]:
+    out = {}
+    for scope, m in sorted(compute(inputs).items()):
+        weeks = m.weeks
+        out[scope] = (
+            m.score,
+            m.level,
+            m.name,
+            m.provisional,
+            len(weeks),
+            sum(w.cost for w in weeks),
+            sum(w.capacity for w in weeks),
+            sum(w.slop for w in weeks),
+        )
+    return out
+
+
+def _read_back(document: dict[str, Any]) -> Any:
+    """The ``slop_meter`` section a repository reads from a deployment document storing ``document``."""
+    section = CATALOG.get("slop_meter")
+    if section is None:
+        pytest.fail("the settings document has no slop_meter section: the meter scores with constants in code")
+    stored = check(CATALOG, document, stored={}).data
+    rows = [{"scope": "deployment", "data": stored, "generation": 1, "updated_at": None}]
+    return build_snapshot(CATALOG, rows, token=(), log=False).scoped(section).repo(REPO)
+
+
+def test_the_fixture_scores_exactly_as_the_code_before_the_section_did() -> None:
+    assert _scored(fixture_inputs()) == GOLDEN, "a repository read with no settings scores as it did before #169"
+
+
+def test_the_default_document_scores_the_fixture_identically_to_the_old_constants() -> None:
+    nothing = _read_back({})
+    assert _scored(replace(fixture_inputs(), settings=nothing)) == GOLDEN, "an empty stored document"
+    every_key = _read_back({"slop_meter": CATALOG.get("slop_meter").defaults().model_dump(mode="json")})  # type: ignore[union-attr]
+    assert _scored(replace(fixture_inputs(), settings=every_key)) == GOLDEN, (
+        "a document that writes every key at its default, through the same read the meter's tick makes"
+    )
+
+
+def test_the_check_for_an_unchanged_score_can_fail() -> None:
+    """The golden comparison is not vacuous: one default moved by a hair changes the fixture's numbers."""
+    for moved in ({"lines_per_hour": 40.5}, {"weights": {"*.sql": 0.81}}, {"test_weight": 0.51}):
+        assert _scored(replace(fixture_inputs(), settings=_read_back({"slop_meter": moved}))) != GOLDEN, moved
+
+
+# ---- the weight of every path, against the rules the code held before (verbatim) ----
+
+_OLD_CORE = (
+    "py", "pyi", "ts", "mts", "cts", "js", "mjs", "cjs", "go", "rs", "java", "kt", "kts", "scala", "c", "h",
+    "cc", "cpp", "cxx", "hpp", "hh", "cs", "rb", "php", "swift", "m", "mm", "ex", "exs", "erl", "clj", "cljs",
+    "hs", "ml", "fs", "lua", "pl", "pm", "r", "jl", "dart", "zig", "nim", "groovy", "sh", "bash", "zsh",
+    "ps1", "tf", "sol", "proto", "graphql", "gql",
+)  # fmt: skip
+_OLD_UI = ("tsx", "jsx", "vue", "svelte", "astro", "html", "htm", "erb", "hbs", "ejs", "jinja", "j2", "twig", "liquid")  # fmt: skip
+_OLD_STYLE = ("css", "scss", "sass", "less", "styl", "pcss")
+_OLD_TYPE_WEIGHTS = {
+    **dict.fromkeys(_OLD_CORE, 1.0),
+    "sql": 0.8,
+    **dict.fromkeys(_OLD_UI, 0.5),
+    **dict.fromkeys(_OLD_STYLE, 0.3),
+}
+_OLD_VENDORED_DIRS = ("vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components")
+_OLD_GENERATED = re.compile(r"(\.min\.(js|css)|\.bundle\.js|\.map|\.d\.ts)\Z")
+_OLD_NON_PRODUCTION_DIRS = (
+    "__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample",
+    "fixtures", "testdata",
+)  # fmt: skip
+_OLD_NON_PRODUCTION_FILE = re.compile(r"(\.(test|spec|stories|story)\.[^.]+|_test\.(go|py|rb|exs?)|_spec\.rb)\Z|(\A|/)test_[^/]+\.py\Z")  # fmt: skip
+
+
+def _old_type_weight(path: str) -> float:
+    lowered = path.lower()
+    parts = lowered.split("/")
+    if any(p in _OLD_VENDORED_DIRS for p in parts[:-1]) or _OLD_GENERATED.search(lowered):
+        return 0.0
+    name = lowered.rsplit("/", 1)[-1]
+    weight = _OLD_TYPE_WEIGHTS.get(name.rsplit(".", 1)[-1].lower() if "." in name else "", 0.0)
+    if weight and (any(p in _OLD_NON_PRODUCTION_DIRS for p in parts[:-1]) or _OLD_NON_PRODUCTION_FILE.search(lowered)):
+        weight *= 0.5
+    return weight
+
+
+def _corpus() -> list[str]:
+    extensions = [*_OLD_TYPE_WEIGHTS, "json", "md", "yaml", "png", "", "min.js", "min.css", "bundle.js", "map"]
+    extensions += ["d.ts", "js.map", "PY", "Ts", "TSX", "snap", "lock", "txt", "gz", "tar.gz"]
+    dirs = ["", "src/", "vendor/", "a/node_modules/b/", "tests/", "Tests/", "pkg/test/", "examples/", "x/__tests__/"]
+    dirs += [
+        "third-party/",
+        "spec/",
+        "fixtures/",
+        "testdata/",
+        "src/vendored/",
+        "lib/deps/",
+        "external/x/",
+        "a.test.d/",
+    ]
+    stems = ["a", "a.test", "a.spec", "a.stories", "a.story", "a.test.helper", "a_test", "a_spec", "test_a", "test_"]
+    stems += ["TEST_x", "x.Test", ".test", "test", "a.min", "foo.bundle", ".", "a..", "b.e2e.spec", "c.spec.e2e"]
+    stems += ["Button.stories.module", "x.d", "y.TEST"]
+    out = [d + s + ("." + e if e else "") for d, s, e in product(dirs, stems, extensions)]
+    rng = random.Random(7)
+    tails = ["", ".py", ".ts", ".js", ".test.ts", "_test.go", ".min.js", ".d.ts", ".css", ".map", ".spec.rb"]
+    for _ in range(50_000):
+        out.append("".join(rng.choice("abcXYZ._-/ te_stpy") for _ in range(rng.randint(1, 18))) + rng.choice(tails))
+    return out
+
+
+def test_every_path_weighs_what_the_rules_before_the_section_weighed_it() -> None:
+    corpus = _corpus()
+    differ = [(p, _old_type_weight(p), type_weight(p)) for p in corpus if _old_type_weight(p) != type_weight(p)]
+    assert len(corpus) > 80_000 and differ == [], f"{len(differ)} of {len(corpus)} paths weigh otherwise: {differ[:10]}"
+
+
+# ---- each key moves the score the way it says ----
+
+
+def _section(values: dict[str, Any]) -> Any:
+    """The section a repository reads from a deployment document writing ``values``: ``weights`` merged over
+    the default globs, as the meter's tick reads it."""
+    return _read_back({"slop_meter": values})
+
+
+def _rules(values: dict[str, Any]) -> Any:
+    settings = _section(values)
+    from embry0.services.slop_meter.weights import FileRules
+
+    return FileRules.of(settings)
+
+
+def test_the_longest_glob_wins_and_a_glob_with_a_slash_matches_from_the_root() -> None:
+    rules = _rules({"weights": {"src/*.py": 2.0, "generated/**": 0.0, "*.sql": 1.0, "migrations/**/*.sql": 0.2}})
+    assert type_weight("src/a.py", rules) == 2.0 and type_weight("lib/src/a.py", rules) == 1.0, (
+        "src/*.py is anchored at the root, and longer than *.py where both match"
+    )
+    assert type_weight("Generated/deep/x.py", rules) == 0.0, "generated/** reaches every file below it, any case"
+    assert type_weight("migrations/v1/up.sql", rules) == 0.2 and type_weight("db/q.sql", rules) == 1.0
+    assert type_weight("src/a_test.py", rules) == 1.0, "the test share applies to the glob's weight (2.0 × 0.5)"
+    assert type_weight("src/tests/a.py", rules) == 0.5, "'*' stays within one name: src/*.py does not reach it"
+    assert type_weight("README.md", rules) == 0.0, "a file no glob matches weighs nothing"
+
+
+def test_what_a_test_is_and_what_it_weighs() -> None:
+    assert type_weight("pkg/a_test.go") == 0.5
+    full = _rules({"test_weight": 1.0})
+    assert type_weight("pkg/a_test.go", full) == 1.0 and type_weight("tests/a.py", full) == 1.0
+    own = _rules({"test_dirs": ["qa"], "test_files": ["*.it.ts"], "test_marks": ["e2e"]})
+    assert type_weight("qa/a.py", own) == 0.5 and type_weight("tests/a.py", own) == 1.0, "a list replaces the default"
+    assert type_weight("src/login.it.ts", own) == 0.5 and type_weight("src/login.e2e.ts", own) == 0.5
+    assert type_weight("src/a.test.ts", own) == 1.0, "test is no longer a mark there"
+    counted = _rules({"excluded_dirs": []})
+    assert type_weight("vendor/lib/a.go", counted) == 1.0 and type_weight("vendor/lib/a.go") == 0.0
+
+
+def _steady_history(weeks: int, per_week: int, lines: int) -> list[Any]:
+    rows = []
+    for w in range(weeks):
+        for i in range(per_week):
+            at = START + timedelta(weeks=w, hours=2 * i)
+            rows.append(_record(f"s{w}-{i}", at, "Dev", "dev@example.com", "Work", [("src/a.py", lines, 0)]))
+    return parse_log("".join(rows))
+
+
+def test_a_slower_pace_reads_more_slop_and_the_levels_are_the_section_s() -> None:
+    commits = _steady_history(weeks=12, per_week=6, lines=120)
+    default = meters(commits, [], {}, Weigher(), {})[""]
+    slower = meters(commits, [], {}, Weigher(), {}, settings=_section({"lines_per_hour": 10}))[""]
+    assert slower.score > default.score, f"fewer lines an hour covers, more slop: {default.score} → {slower.score}"
+    names = ["Clean", "Fine", "Mixed", "Sloppy", "Slop"]
+    banded = meters(commits, [], {}, Weigher(), {}, settings=_section({"lines_per_hour": 10, "level_names": names}))
+    assert banded[""].name in names and banded[""].score == slower.score, "a name is data; the score is not moved"
+    from embry0.services.slop_meter.score import level_of
+
+    tight = _section({"level_bounds": [0.01, 0.02, 0.03, 0.04]})
+    assert level_of(0.035, tight) == (4, "Sloppy Joe") and level_of(0.5, tight) == (5, "Just The Slop")
+
+
+def test_a_small_repository_reads_as_the_published_algorithm_with_the_departure_off() -> None:
+    drop = "".join(
+        _record(
+            f"d{i}", START + timedelta(hours=6 * i), "Dev", "dev@example.com", "More", [(f"src/m{i}.py", 10_000, 0)]
+        )
+        for i in range(5)
+    )
+    commits = parse_log(drop)
+    assert meters(commits, [], {}, Weigher(), {})[""].score == pytest.approx(0.796, abs=1e-3), "embry0's rule"
+    written = meters(commits, [], {}, Weigher(), {}, settings=_section({"small_repository_in_full": False}))
+    assert written[""].score == pytest.approx(0.8), "as written, the five-commit author counts for nothing"
+
+
+def test_an_ai_agent_of_the_section_co_authors_as_an_agent_and_authors_as_a_bot() -> None:
+    agents = _section({"ai_agents": ["helper-agent@"]}).ai_agents
+    from embry0.services.slop_meter.history import agent_prefixes, own_identities, with_bots
+
+    body = "x\n\nCo-authored-by: Helper <helper-agent@tools.example>\n"
+    commits = parse_log(
+        _record("h1", START, "Ana", "ana@example.com", body, [("src/a.py", 10, 0)])
+        + _record("h2", START + timedelta(hours=2), "Helper", "Helper-Agent@tools.example", "x", [("src/b.py", 5, 0)])
+    )
+    assert not commits[0].ai_coauthor and not commits[1].bot, "an agent no deployment knows reads as a person"
+    human, agent = with_bots(commits, own_identities(), agent_prefixes(agents))
+    assert human.ai_coauthor and human.coauthors == (), "its co-authorship is an agent's"
+    assert agent.bot, "and a commit it authors adds no attention"
+
+
+def test_the_judge_is_told_the_section_s_guidance_then_the_answer_s_form() -> None:
+    guidance = _section({"judge_prompt": "Slop is code no person read.\n"}).judge_prompt
+    from embry0.services.slop_meter.judge import ANSWER_FORM, system_prompt
+
+    assert system_prompt(guidance) == f"Slop is code no person read.\n{ANSWER_FORM}"
diff --git a/tests/unit/services/test_background_scope_transients.py b/tests/unit/services/test_background_scope_transients.py
index e7e664e4..e1312e0d 100644
--- a/tests/unit/services/test_background_scope_transients.py
+++ b/tests/unit/services/test_background_scope_transients.py
@@ -24,7 +24,7 @@
 
 from embry0.config import Embry0Config
 from embry0.services.slop_meter.history import Commit
-from embry0.services.slop_meter.loop import SlopMeterLoop, SlopMeterSettings
+from embry0.services.slop_meter.loop import SlopMeterLimits, SlopMeterLoop
 from embry0.services.slop_meter.mirror import GitMirror
 from embry0.settings.scope import Scope
 from embry0.settings.store import SettingsStore
@@ -106,7 +106,7 @@ async def no_bots(repo: str) -> tuple[str, ...]:
         client_for=nothing,
         bots=no_bots,
         calls=None,  # type: ignore[arg-type]
-        settings=SlopMeterSettings(),
+        limits=SlopMeterLimits(),
         clock=lambda: clock[0],
     )
     return loop, store, clock, audit
@@ -228,7 +228,7 @@ async def nothing(repo: str) -> None:
         client_for=nothing,
         bots=nothing,
         calls=None,  # type: ignore[arg-type]
-        settings=SlopMeterSettings(),
+        limits=SlopMeterLimits(),
     )
     read_counts = []
     for _tick in range(3):
diff --git a/tests/unit/settings/test_budget_section.py b/tests/unit/settings/test_budget_section.py
index 652fa4e1..f5aa28b9 100644
--- a/tests/unit/settings/test_budget_section.py
+++ b/tests/unit/settings/test_budget_section.py
@@ -110,6 +110,7 @@ def test_each_moved_organization_setting_lands_on_a_key_an_organization_may_set(
         "context_audit_max_jobs_per_tick": "budget.context_audit_max_jobs_per_tick",
         "context_audit_days": "context_audit.days",
         "context_audit_open_prs": "context_audit.open_prs",
+        "slop_meter_bots": "slop_meter.bots",
     }
 
 
diff --git a/tests/unit/settings/test_registry.py b/tests/unit/settings/test_registry.py
index ab515193..1fff1f51 100644
--- a/tests/unit/settings/test_registry.py
+++ b/tests/unit/settings/test_registry.py
@@ -276,13 +276,15 @@ def test_the_catalog_lists_one_section_per_line_sorted_by_name() -> None:
 #: import cycle can pass through them (``test_the_leaves_a_section_may_import_import_nothing_of_embry0``):
 #: the content pack's template grammar, which the salvage subject is written in, and the one rule a
 #: named heading matches a ticket's heading by, which the done_when section checks its headings with,
-#: the lead-kind catalogue, whose kinds and severities the leads section's ask_severities names, and the
-#: instruction-file rules, whose glob grammar the context_audit section checks its globs with.
+#: the lead-kind catalogue, whose kinds and severities the leads section's ask_severities names, the
+#: instruction-file rules, whose glob grammar the context_audit section checks its globs with, and the
+#: Slop-O-Meter's file names, whose glob grammar the slop_meter section checks its globs with.
 LEAF_IMPORTS = frozenset(
     {
         "embry0.services.instruction_files",
         "embry0.services.lead_kinds",
         "embry0.services.progression_templates",
+        "embry0.services.slop_meter.globs",
         "embry0.ticket_headings",
     }
 )
diff --git a/tests/unit/settings/test_slop_meter_section.py b/tests/unit/settings/test_slop_meter_section.py
new file mode 100644
index 00000000..abade3db
--- /dev/null
+++ b/tests/unit/settings/test_slop_meter_section.py
@@ -0,0 +1,310 @@
+"""The ``slop_meter`` section of the settings document (#169): the YAML an operator writes, and what it refuses.
+
+Nothing written keeps the meter exactly as it scored before the section: the
+defaults are pinned here against the constants the meter's code held, so a
+default that drifts silently rescoring every repository fails with its own
+message. The section is read through the catalog, so each test fails with its
+own message on a tree that has no slop_meter section.
+"""
+
+from __future__ import annotations
+
+import os
+from collections.abc import Mapping
+from typing import Any
+from unittest.mock import patch
+
+import pytest
+
+from embry0.config import Embry0Config
+from embry0.settings.bootstrap import env_values
+from embry0.settings.document import DocumentInvalid, check, load_yaml
+from embry0.settings.registry import Section
+from embry0.settings.sections import CATALOG
+from embry0.settings.store import Snapshot, build_snapshot
+
+WIDGETS = "acme/widgets"
+GADGETS = "globex/gadgets"
+
+# ---- what the meter's code held before the section (embry0/services/slop_meter/*.py at 65cf0eaf) ----
+
+OLD_CORE = (
+    "py", "pyi", "ts", "mts", "cts", "js", "mjs", "cjs", "go", "rs", "java", "kt", "kts", "scala", "c", "h",
+    "cc", "cpp", "cxx", "hpp", "hh", "cs", "rb", "php", "swift", "m", "mm", "ex", "exs", "erl", "clj", "cljs",
+    "hs", "ml", "fs", "lua", "pl", "pm", "r", "jl", "dart", "zig", "nim", "groovy", "sh", "bash", "zsh",
+    "ps1", "tf", "sol", "proto", "graphql", "gql",
+)  # fmt: skip
+OLD_UI = ("tsx", "jsx", "vue", "svelte", "astro", "html", "htm", "erb", "hbs", "ejs", "jinja", "j2", "twig", "liquid")  # fmt: skip
+OLD_STYLE = ("css", "scss", "sass", "less", "styl", "pcss")
+OLD_VENDORED = ("vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components")
+OLD_TEST_DIRS = (
+    "__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample",
+    "fixtures", "testdata",
+)  # fmt: skip
+OLD_NUMBERS = {
+    "bootstrap_lines": 5_000,  # BOOTSTRAP_THRESHOLD
+    "complexity_weight": 0.05,  # COMPLEXITY_WEIGHT
+    "commit_hours": 1.0,  # BASE_NEIGHBORHOOD
+    "event_hours": 1.0,  # BASE_NEIGHBORHOOD, for a forge event
+    "subcommit_hours": 1.0,  # MARGINAL_HOURS_PER_SUBCOMMIT
+    "ai_coauthor_share": 0.8,  # AI_CO_AUTHOR_ATTENTION_WEIGHT
+    "coauthor_shares": [0.5, 0.25, 0.125],  # CO_AUTHOR_WEIGHTS
+    "lines_per_hour": 40.0,  # LINES_PER_HOUR
+    "core_min_commits": 10,  # CORE_RAMP_START
+    "core_full_commits": 60,  # CORE_RAMP_END
+    "weekly_hours_cap": 80.0,  # WEEKLY_HOURS_CAP
+    "outlier_min_lines": 2_000,  # OUTLIER_MIN_ADDITIONS
+    "outliers_per_year": 4,  # OUTLIERS_PER_YEAR
+    "test_weight": 0.5,  # NON_PRODUCTION_WEIGHT
+    "level_bounds": [0.2, 0.4, 0.6, 0.8],  # LEVELS
+    "level_names": ["Buttered Noodles", "Spaghetti Bolognese", "Lasagna", "Sloppy Joe", "Just The Slop"],
+    "small_repository_in_full": True,  # the small-repository rule, always on
+    "interval_hours": 24.0,  # SLOP_METER_INTERVAL_SECONDS=86400
+    "api_calls_per_tick": 200,  # SLOP_METER_API_CALLS_PER_TICK
+    "rate_reserve": 2_000,  # SLOP_METER_RATE_RESERVE
+    "enabled": True,
+    "bots": [],
+    "ai_agents": [],
+}
+OLD_SYSTEM_PROMPT = """\
+You judge one large commit of a software repository: did it add bulk code no
+person wrote or reviewed line by line (slop, such as a large AI-generated
+change), or is its size explained by something else (not slop: the project's
+initial import, a code drop moved in from elsewhere, a restructuring that moved
+files, a vendored or generated library, a data or fixture dump)?
+Judge from what the message and the files say. When it is unclear, answer
+slop: false only if the files themselves look moved, vendored or generated.
+Answer with JSON: {"slop": true|false, "reason": "<one plain sentence>"}."""
+
+
+def _section() -> Section[Any]:
+    found = CATALOG.get("slop_meter")
+    if found is None:
+        pytest.fail("the settings document has no slop_meter section: the meter's weights and pace are code")
+    return found
+
+
+def _defaults() -> dict[str, Any]:
+    return _section().defaults().model_dump(mode="json")
+
+
+def _problems(values: Mapping[str, Any]) -> dict[str, str]:
+    """Each key a document holding ``slop_meter: values`` is refused at, with its message."""
+    _section()
+    try:
+        check(CATALOG, {"slop_meter": dict(values)}, stored={})
+    except DocumentInvalid as exc:
+        return {".".join(str(part) for part in problem.loc[1:]): problem.msg for problem in exc.problems}
+    return {}
+
+
+def _snapshot(documents: Mapping[str, Mapping[str, Any]]) -> Snapshot:
+    """A snapshot of ``documents``, each stored scope to its ``slop_meter`` values, as the store builds one."""
+    rows = [
+        {"scope": scope, "data": {"slop_meter": dict(values)}, "generation": 1, "updated_at": None}
+        for scope, values in documents.items()
+    ]
+    if "deployment" not in documents:
+        rows.append({"scope": "deployment", "data": {}, "generation": 1, "updated_at": None})
+    return build_snapshot(CATALOG, rows, token=(), log=False)
+
+
+# ---- nothing written scores as before ----
+
+
+def test_nothing_written_holds_the_constants_the_meter_scored_with_before() -> None:
+    defaults = _defaults()
+    weights = {
+        **{f"*.{e}": 1.0 for e in OLD_CORE},
+        "*.sql": 0.8,
+        **{f"*.{e}": 0.5 for e in OLD_UI},
+        **{f"*.{e}": 0.3 for e in OLD_STYLE},
+        **dict.fromkeys(("*.min.js", "*.min.css", "*.bundle.js", "*.map", "*.d.ts"), 0.0),
+    }
+    assert defaults["weights"] == weights, "every extension the meter weighed, at its weight, and the generated 0s"
+    assert defaults["excluded_dirs"] == list(OLD_VENDORED), "the vendored directories it excluded"
+    assert defaults["test_dirs"] == list(OLD_TEST_DIRS), "the directories of tests and examples"
+    assert defaults["test_files"] == ["*_test.go", "*_test.py", "*_test.rb", "*_test.ex", "*_test.exs", "*_spec.rb", "test_?*.py"]  # fmt: skip
+    assert defaults["test_marks"] == ["test", "spec", "stories", "story"]
+    assert {key: defaults[key] for key in OLD_NUMBERS} == OLD_NUMBERS, "each number the meter's code held"
+    from embry0.services.slop_meter.judge import system_prompt
+
+    assert system_prompt(defaults["judge_prompt"]) == OLD_SYSTEM_PROMPT, "the judge is told what it was told"
+
+
+def test_every_default_glob_and_name_is_one_the_section_accepts() -> None:
+    defaults = _defaults()
+    assert _problems(defaults) == {}, "a document that writes every default must be accepted"
+
+
+# ---- what it refuses, naming every key ----
+
+
+def test_every_refused_key_is_named_in_one_answer() -> None:
+    problems = _problems(
+        {
+            "weights": {"*.PY": 1.0},
+            "excluded_dirs": ["vendor", "vendor"],
+            "test_files": ["tests/**/**/x.py"],
+            "test_marks": ["test.unit"],
+            "test_weight": 1.5,
+            "level_bounds": [0.2, 0.2, 0.6, 0.8],
+            "level_names": ["One", "Two", "Three", "Four"],
+            "bots": ["release-bot", "Release-Bot"],
+            "ai_agents": ["aider @"],
+            "judge_prompt": "  \n ",
+            "interval_hours": 0.1,
+            "lines_per_hour": 0,
+        }
+    )
+    assert set(problems) == {
+        "weights",
+        "excluded_dirs",
+        "test_files",
+        "test_marks",
+        "test_weight",
+        "level_bounds",
+        "level_names",
+        "bots",
+        "ai_agents",
+        "judge_prompt",
+        "interval_hours",
+        "lines_per_hour",
+    }, f"one answer names every refused key: {problems}"
+    assert "lowercase" in problems["weights"] and "once" in problems["excluded_dirs"]
+    assert "above the one before" in problems["level_bounds"] and "once" in problems["bots"]
+
+
+@pytest.mark.parametrize(
+    ("weights", "says"),
+    [
+        ({"": 1.0}, "write a glob"),
+        ({"/src/*.py": 1.0}, "starts at the repository's root"),
+        ({"src//a.py": 1.0}, "doubled"),
+        ({"src/a**.py": 1.0}, "stands alone"),
+        ({"**": 1.0}, "every file"),
+        ({"../x.py": 1.0}, "'.' or '..'"),
+        ({"*.[ch]": 1.0}, "only lowercase letters"),
+        ({"*.py": 11}, "from 0 to 10"),
+        ({"*.py": -1}, "from 0 to 10"),
+    ],
+)
+def test_a_glob_or_weight_the_meter_cannot_read_is_refused_without_repeating_it(weights: Any, says: str) -> None:
+    problems = _problems({"weights": weights})
+    assert says in problems.get("weights", ""), f"{weights}: {problems}"
+    glob = next(iter(weights))
+    if len(glob) > 3:
+        assert glob not in problems["weights"], "the message never repeats the text"
+
+
+def test_the_core_ramp_must_rise_and_a_level_name_is_one_line() -> None:
+    assert "ramp" in " ".join(_problems({"core_min_commits": 60, "core_full_commits": 60}).values())
+    assert "one line" in _problems({"level_names": ["A", "B", "C", "D", "E\nF"]})["level_names"]
+    assert "plain text" in _problems({"judge_prompt": "Judge\u202ethis"})["judge_prompt"]
+    assert _problems({"judge_prompt": "Judge this.\n\tSlop is bulk code no person read."}) == {}
+
+
+# ---- layers ----
+
+
+def test_an_organization_says_what_counts_and_a_repository_says_its_layout() -> None:
+    section = _section()
+    assert section.settable("organization") == frozenset(section.fields) - {"enabled", "interval_hours"}, (
+        "an organization may set every key but whether the meter runs and how often"
+    )
+    assert section.settable("repository") == {"weights", "excluded_dirs", "test_dirs", "test_files", "test_marks"}
+    assert section.merged_keys == {"weights"}, "weights merge entry by entry"
+
+
+def test_weights_merge_entry_by_entry_through_every_layer() -> None:
+    snapshot = _snapshot(
+        {
+            "deployment": {"weights": {"*.sql": 1.0}, "lines_per_hour": 30},
+            "organization:acme": {"weights": {"*.css": 0.0}, "lines_per_hour": 20, "api_calls_per_tick": 50},
+            f"repository:{WIDGETS}": {"weights": {"db/migrations/**": 0.0}, "lines_per_hour": 10},
+        }
+    )
+    _section()
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    widgets = snapshot.scoped(SLOP_METER).repo(WIDGETS)
+    assert widgets.weights["*.sql"] == 1.0 and widgets.weights["*.css"] == 0.0, "the deployment's and acme's entries"
+    assert widgets.weights["db/migrations/**"] == 0.0 and widgets.weights["*.py"] == 1.0, "its own, and the defaults"
+    assert widgets.lines_per_hour == 20, "a repository cannot set its team's pace: acme's applies"
+    assert widgets.api_calls_per_tick == 50, "acme's forge budget"
+    gadgets = snapshot.scoped(SLOP_METER).repo(GADGETS)
+    assert gadgets.weights["*.css"] == 0.3 and gadgets.lines_per_hour == 30, (
+        "another organization reads the deployment's"
+    )
+
+
+# ---- the configuration version ----
+
+
+def test_the_configuration_version_follows_what_a_score_is_computed_from_and_nothing_else() -> None:
+    section = _section()
+    from embry0.settings.sections.slop_meter import NOT_SCORED, config_version
+
+    base = config_version(section.defaults())
+    assert base == config_version(section.validate({})) and len(base) == 16, "stable, for the same values"
+    assert config_version(section.validate({"weights": {"*.sql": 1.0}})) != base, "a weight changes it"
+    assert config_version(section.validate({"level_names": ["A", "B", "C", "D", "E"]})) != base
+    assert config_version(section.validate({"bots": ["release-bot"]})) != base
+    for key, value in {
+        "enabled": False,
+        "interval_hours": 2.0,
+        "api_calls_per_tick": 5,
+        "rate_reserve": 10,
+        "judge_prompt": "Judge it.",
+    }.items():
+        assert key in NOT_SCORED
+        assert config_version(section.validate({key: value})) == base, f"{key} is not what a score is computed from"
+    reordered = dict(reversed(list(section.defaults().weights.items())))
+    assert config_version(section.validate({"weights": reordered})) == base, "the order globs are written in is not"
+
+
+# ---- the import from the environment ----
+
+
+def _imported(**env: str) -> dict[str, Any]:
+    _section()
+    with patch.dict(os.environ, env, clear=True):
+        config = Embry0Config(_env_file=None)  # type: ignore[call-arg]
+    return env_values(CATALOG, config).values.get("slop_meter", {})
+
+
+def test_the_reading_pace_is_imported_from_its_variables_once() -> None:
+    assert _imported() == {}, "nothing set, nothing imported: a code default is never imported"
+    assert _imported(SLOP_METER_INTERVAL_SECONDS="0") == {"enabled": False}, "0 turned the reading off"
+    assert _imported(SLOP_METER_INTERVAL_SECONDS="86400") == {}, "the default interval is not imported"
+    assert _imported(SLOP_METER_INTERVAL_SECONDS="3600") == {"interval_hours": 1.0}
+    assert _imported(SLOP_METER_INTERVAL_SECONDS="60") == {"interval_hours": 0.25}, "at least a quarter hour"
+    assert _imported(SLOP_METER_API_CALLS_PER_TICK="50", SLOP_METER_RATE_RESERVE="500") == {
+        "api_calls_per_tick": 50,
+        "rate_reserve": 500,
+    }
+    assert (
+        _imported(SLOP_METER_COMMITS_PER_TICK="10", SLOP_METER_DATA_PATH="/x", SLOP_METER_CATCHUP_SECONDS="9") == {}
+    ), "the process's own limits stay variables"
+
+
+def test_the_section_reads_as_an_operator_writes_it() -> None:
+    _section()
+    text = (
+        "slop_meter:\n"
+        "  interval_hours: 12\n"
+        "  weights:\n"
+        '    "*.sql": 1\n'
+        '    "db/migrations/**": 0\n'
+        "  lines_per_hour: 30\n"
+        "  level_names: [Clean, Fine, Mixed, Sloppy, Slop]\n"
+        "  bots: [release-bot, ci@acme.example]\n"
+    )
+    data = check(CATALOG, load_yaml(text), stored={}).data["slop_meter"]
+    assert data == {
+        "interval_hours": 12.0,
+        "weights": {"*.sql": 1.0, "db/migrations/**": 0.0},
+        "lines_per_hour": 30.0,
+        "level_names": ["Clean", "Fine", "Mixed", "Sloppy", "Slop"],
+        "bots": ["release-bot", "ci@acme.example"],
+    }, data
diff --git a/tests/unit/storage/test_migration_143.py b/tests/unit/storage/test_migration_143.py
index 7b37b7f9..f7392d99 100644
--- a/tests/unit/storage/test_migration_143.py
+++ b/tests/unit/storage/test_migration_143.py
@@ -28,10 +28,8 @@
 JOB_COLUMNS = ("coding_agent", "leader_agent")
 
 
-def test_the_behaviour_rows_migration_is_the_last_entry() -> None:
-    """The newest migration owns this assertion; it passes to the next one
-    (it came from tests/unit/storage/test_migration_142.py)."""
-    assert MIGRATIONS[-1][0] == VERSION, f"migration {VERSION} must add the template and agent behaviour columns"
+def test_the_behaviour_rows_migration_is_listed_once() -> None:
+    """The "last entry" assertion passed to tests/unit/storage/test_migration_144.py."""
     assert [v for v, _, _ in MIGRATIONS].count(VERSION) == 1, f"migration {VERSION} must be listed once"
 
 
diff --git a/tests/unit/storage/test_migration_144.py b/tests/unit/storage/test_migration_144.py
new file mode 100644
index 00000000..d536f685
--- /dev/null
+++ b/tests/unit/storage/test_migration_144.py
@@ -0,0 +1,71 @@
+"""Migration 144 — ``slop_meter_scores.config_version``, the settings a Slop-O-Meter score was computed from (#169).
+
+The number is ``VERSION`` alone: renumbering the migration changes that line and this file's name.
+"""
+
+from __future__ import annotations
+
+from datetime import UTC, date, datetime
+
+import pytest
+
+from embry0.services.slop_meter.score import Meter, Week
+from embry0.storage.database import DatabasePool
+from embry0.storage.migrations.runner import MIGRATIONS, run_migrations
+from embry0.storage.repositories.slop_meter import SlopMeterRepository
+
+#: This migration's number.
+VERSION = 144
+
+AT = datetime(2026, 10, 26, 6, tzinfo=UTC)
+REPO = "acme/widgets"
+
+
+def test_the_score_version_migration_is_the_last_entry() -> None:
+    """The newest migration owns this assertion; it passes to the next one
+    (it came from tests/unit/storage/test_migration_143.py)."""
+    assert MIGRATIONS[-1][0] == VERSION, f"migration {VERSION} must add slop_meter_scores.config_version"
+    assert [v for v, _, _ in MIGRATIONS].count(VERSION) == 1, f"migration {VERSION} must be listed once"
+
+
+async def _column(db: DatabasePool) -> dict[str, str] | None:
+    row = await db.fetchrow(
+        "SELECT data_type, is_nullable, column_default FROM information_schema.columns "
+        "WHERE table_name = 'slop_meter_scores' AND column_name = 'config_version'"
+    )
+    return dict(row) if row is not None else None
+
+
+@pytest.mark.requires_postgres
+async def test_a_score_from_before_names_no_version_and_a_new_one_records_its_own(
+    db_with_migrations: DatabasePool,
+) -> None:
+    """Upgrading keeps every stored score, with an empty version that no digest equals, so the next run
+    records one; a score stored after it records the version it was given."""
+    db = db_with_migrations
+    assert await _column(db) is not None, "slop_meter_scores has no config_version column after migrating"
+    await db.execute("ALTER TABLE slop_meter_scores DROP COLUMN config_version")
+    await db.execute("DELETE FROM embry0_migrations WHERE version = $1", VERSION)
+    await db.execute(
+        "INSERT INTO slop_meter_scores (repo, area, score, level, name, provisional, commits, computed_at) "
+        "VALUES ($1, '', 0.4, 3, 'Lasagna', false, 12, $2)",
+        REPO,
+        AT,
+    )
+    await run_migrations(db)
+
+    column = await _column(db)
+    assert column is not None and (column["data_type"], column["is_nullable"]) == ("text", "NO"), column
+    assert column["column_default"] == "''::text", f"a row written without one gets none: {column['column_default']}"
+    store = SlopMeterRepository(db)
+    [before] = await store.scores(REPO)
+    assert (before["name"], before["config_version"]) == ("Lasagna", ""), (
+        f"the score stored before the migration is kept, naming no version: {before}"
+    )
+
+    week = Week(date(2026, 10, 19), 100.0, 80.0, 20.0, 900.0, 0.2)
+    await store.store(REPO, {"": Meter(0.2, 2, "Spaghetti Bolognese", False, [week], 13)}, AT, config_version="v-1")
+    [after] = await store.scores(REPO)
+    assert (after["name"], after["config_version"]) == ("Spaghetti Bolognese", "v-1"), (
+        f"a score records the configuration version it was computed with: {after}"
+    )

From 743294b708965e5a5879be7c986481f3426224c8 Mon Sep 17 00:00:00 2001
From: Tomas McMonigal <74835766+sudoTomas@users.noreply.github.com>
Date: Fri, 6 Nov 2026 14:21:13 +0000
Subject: [PATCH 2/4] feat(slop): the Slop-O-Meter's scoring as a settings
 section

The meter kept all of its policy in code: the file weights and which
directories are vendored or tests, the pace and cap constants, the
small-repository rule, the level bounds and names and the judge's
prompt. An organization could not say what counts as code, how fast
its team works or where its levels fall, and changing a constant
silently rescored every repository. Its reading pace was three
variables, and an owner's own bots sat on its organization row.

Add a `slop_meter` section to the settings document. Every constant is
a key whose default is the value the code held, so nothing written
scores bit for bit as before: a fixture history reproduces the pinned
pre-change numbers, and 86,000 paths weigh what the old rules gave
them. An organization's layer may set every key but `enabled` and
`interval_hours`; a repository's what counts as code in its layout.
`weights` maps a glob to a weight, merged glob by glob through every
layer. Weigh paths by specificity: a folder glob beats any extension
glob, then more literal segments, then more literal characters. Globs
are indexed by extension and first directory and each path is weighed
once a run, in a thread.

Each score row records `config_version` (migration 144), a digest of
the keys its repository's score is computed from. The loop looks at
the section every five minutes: a settings change rescores only the
repositories it touches, from the rows and mirrors already read, with
no fetch, forge call or judgment, and the full run keeps its interval.
`enabled` and `interval_hours` apply within the look. A credential's
forge budget is the deployment's; an organization's values only narrow
its own share. `bots` and `ai_agents` add to what each layer inherits
(a new `added_keys` for list fields), and an AI agent is an address or
the part of one up to its `@`.

SLOP_METER_INTERVAL_SECONDS (0 is `enabled: false`),
SLOP_METER_API_CALLS_PER_TICK and SLOP_METER_RATE_RESERVE are imported
once and read as before until the import succeeds. The organization
setting `slop_meter_bots` moves into its layer as `bots`, cleaned
(each bot once, unholdable entries left out) at the first start and on
PATCH or POST /orgs, which still take it until 0.2.0. The process
limits stay variables. The unread LEAN_LEVEL constant is deleted:
triage's lean belongs to the routing section a later pull request
adds. Multi-line texts in the settings YAML are written as literal
blocks; progression packs keep their own writer.

Refs #169
---
 docs/api.md                                   |   2 +-
 docs/architecture.md                          |   2 +-
 docs/configuration.md                         |  14 +-
 docs/examples/settings.yaml                   |  47 ++--
 docs/slop-meter.md                            |  36 ++-
 embry0/api/app.py                             |   2 +-
 embry0/api/v1/organizations.py                |  31 ++-
 embry0/services/organizations.py              |  57 ++++-
 embry0/services/slop_meter/events.py          |  46 +++-
 embry0/services/slop_meter/globs.py           | 100 ++++++++
 embry0/services/slop_meter/history.py         |  10 +-
 embry0/services/slop_meter/loop.py            | 240 +++++++++++++-----
 embry0/services/slop_meter/weights.py         |  88 ++++---
 embry0/settings/effective.py                  |  31 ++-
 embry0/settings/layers.py                     |  20 +-
 embry0/settings/reference.py                  |   6 +-
 embry0/settings/registry.py                   |  15 +-
 embry0/settings/sections/slop_meter.py        |  95 ++++---
 embry0/storage/repositories/slop_meter.py     |   5 +
 .../unit/api/test_background_scope_wiring.py  |   5 +-
 .../unit/api/test_slop_meter_settings_live.py |  65 ++++-
 tests/unit/services/slop_meter/test_loop.py   |   7 +-
 .../services/slop_meter/test_loop_settings.py | 214 +++++++++++-----
 tests/unit/services/slop_meter/test_prune.py  |   2 +-
 .../slop_meter/test_scoring_settings.py       |  59 ++++-
 tests/unit/settings/test_layers.py            |  29 +++
 .../unit/settings/test_slop_meter_section.py  |  44 +++-
 27 files changed, 991 insertions(+), 281 deletions(-)

diff --git a/docs/api.md b/docs/api.md
index 16f66f6a..19262db7 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -743,7 +743,7 @@ A repository whose `context_audit.days` is set (the [settings document](configur
 | `context_audit_open_prs` | boolean | off | Deprecated: the organization's layer of `context_audit.open_prs` now. Taken until 0.2.0, see below |
 | `slop_meter_bots` | list of up to 100 strings, each at most 200 characters | empty | Deprecated: the organization's layer of the settings document's `slop_meter.bots` now. Taken until 0.2.0, see below |
 
-**Moved settings.** `context_audit_budget_usd` and `context_audit_max_jobs_per_tick` are the organization's layer of the settings document's `budget` section now, as `context_audit_job_usd` and `context_audit_max_jobs_per_tick` (`PATCH /api/v1/config/settings/budget?owner=acme`), where an organization may also set `area_map_job_usd` and `fix_job_usd`. `context_audit_days` and `context_audit_open_prs` are its layer of the `context_audit` section, as `days` and `open_prs` (`PATCH /api/v1/config/settings/context_audit?owner=acme`), where a repository's own layer may set them too and `days: false` turns the schedule off whatever the layer below says (#170). `slop_meter_bots` is its layer of the `slop_meter` section, as `bots` (`PATCH /api/v1/config/settings/slop_meter?owner=acme`): the owner's own bots, which the Slop-O-Meter counts as a bot's work, not a person's attention, beside embry0's own commit identities, applied to every reading, history read before they were listed included (#169). Each organization's list was copied with its blanks left out and each name once, without regard to case. The first start of each release that moved them copied each organization's value into its layer once, when the old reader would have used it (a value it read as the deployment's is nothing to copy); the value left on the organization is read by nothing, and `GET /api/v1/orgs` no longer shows it. Until 0.2.0, `PATCH` and `POST /api/v1/orgs` still take them, checked as above, and write them into the organization's layer instead, with every rule of that route (a revision with source `person`, a `settings.updated` audit row, a key with no repository allowlist); `null` takes the key out of the layer, so the organization reads the deployment's value. The answer then carries `deprecated`: one `{"setting", "moved_to", "removed_in", "detail"}` per moved setting it took. 0.2.0 refuses them.
+**Moved settings.** `context_audit_budget_usd` and `context_audit_max_jobs_per_tick` are the organization's layer of the settings document's `budget` section now, as `context_audit_job_usd` and `context_audit_max_jobs_per_tick` (`PATCH /api/v1/config/settings/budget?owner=acme`), where an organization may also set `area_map_job_usd` and `fix_job_usd`. `context_audit_days` and `context_audit_open_prs` are its layer of the `context_audit` section, as `days` and `open_prs` (`PATCH /api/v1/config/settings/context_audit?owner=acme`), where a repository's own layer may set them too and `days: false` turns the schedule off whatever the layer below says (#170). `slop_meter_bots` is its layer of the `slop_meter` section, as `bots` (`PATCH /api/v1/config/settings/slop_meter?owner=acme`): the owner's own bots, which the Slop-O-Meter counts as a bot's work, not a person's attention, beside embry0's own commit identities, applied to every reading, history read before they were listed included, and added to the bots the deployment lists (#169). Each organization's list was copied, and a list `PATCH` or `POST` takes is written, with its blanks left out, each name once without regard to case, and an entry the section cannot hold (a line break, a tab, a control or format character) left out and logged (`slop_meter_bots_entries_dropped`) rather than refusing the rest. The first start of each release that moved them copied each organization's value into its layer once, when the old reader would have used it (a value it read as the deployment's is nothing to copy); the value left on the organization is read by nothing, and `GET /api/v1/orgs` no longer shows it. Until 0.2.0, `PATCH` and `POST /api/v1/orgs` still take them, checked as above, and write them into the organization's layer instead, with every rule of that route (a revision with source `person`, a `settings.updated` audit row, a key with no repository allowlist); `null` takes the key out of the layer, so the organization reads the deployment's value. The answer then carries `deprecated`: one `{"setting", "moved_to", "removed_in", "detail"}` per moved setting it took. 0.2.0 refuses them.
 
 `GET` and `POST /api/v1/orgs/{owner}/webhook` inspect and install the organization's one GitHub webhook, and the receiver's gate handles deliveries for repositories nobody registered ([webhooks.md](webhooks.md#organization-webhooks-github), [ADR 0012](adr/0012-organization-webhook.md)).
 
diff --git a/docs/architecture.md b/docs/architecture.md
index 08461ae0..ca7b4016 100644
--- a/docs/architecture.md
+++ b/docs/architecture.md
@@ -1390,7 +1390,7 @@ The whole pass is serialised across processes by a session-level Postgres adviso
 | 141 | the repository of a job posted with a git context alone: fills `jobs.repo` from `context->>'repo'` where `repo` is NULL and the context is git, so `GET /jobs?repo=`, the world view and the stats find it (`POST /jobs` stores it now); a row naming a repository and any other context are left alone, `updated_at` is kept, and a second run changes nothing | `jobs.repo` (data) |
 | 142 | the skills triage may add to an agent: `agent_definitions.triage_may_add_skills`, a JSON array of `source:skill` names (NOT NULL, default `[]`); triage adds one only from a source the agent's skills already load. The built-in developer row gets `superpowers:brainstorming` and `superpowers:writing-plans`, the two the triage prompt always offered it, so an upgraded deployment keeps its behaviour; every other row, and a deployment without that row, gets none | `agent_definitions.triage_may_add_skills` |
 | 143 | behaviour from agent and template rows, not built-in names (#167): `pipeline_templates.fixed_route` (NOT NULL, default false), `offered_to_triage` (NOT NULL, default true), `job_kind` (an override; NULL reads the route), `delivers` (NOT NULL, default `''`) and `leader_agent`; `agent_definitions.station` (NOT NULL, default `desk`) and `quest_template` (NULL none, `''` a task naming no template); `jobs.coding_agent` and `jobs.leader_agent`, which plan_route records and progression credits from. Every row gets what the code said of its name before: the ten specialist templates fixed and not offered, the leaders and deliverables of the old maps, the old stations and guild tasks; a slop-cleanup job coded by the Slopmaster and every job led by its template's old leader. A template named `qa`, `onboard` or `pr-review` is renamed `<name>-template` | `pipeline_templates`, `agent_definitions`, `jobs` |
-| 144 | each Slop-O-Meter score's configuration version: `slop_meter_scores.config_version` (NOT NULL, default `''`), a digest of the `slop_meter` settings the score was computed from (#169). A score stored before it names none, which no digest equals, so the meter's next run rescores it and records one | `slop_meter_scores.config_version` |
+| 144 | each Slop-O-Meter score's configuration version: `slop_meter_scores.config_version` (NOT NULL, default `''`), a digest of the `slop_meter` settings the score was computed from (#169). The meter compares it with the version each repository reads now and rescores the ones that differ. A score stored before it names none, which no digest equals; the first run after the upgrade, which scores every repository it reads, records one | `slop_meter_scores.config_version` |
 
 Note: LangGraph's checkpoint tables (`checkpoints`, `checkpoint_blobs`, `checkpoint_writes`) are created and mutated by `langgraph-checkpoint-postgres` / `orchestration/checkpoint.py`, outside `embry0_migrations` entirely — they're excluded from this ledger by design, not an oversight.
 
diff --git a/docs/configuration.md b/docs/configuration.md
index 4f012328..79286a40 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -307,7 +307,7 @@ asks:
 - **In the dashboard**, Settings → Policy holds the same three things, for one document at a time. The **Layer** picker above them chooses the deployment's document, an organization's layer or a repository's: it offers every organization and repository the lists show and every stored layer, each marked with how many keys its layer sets, and keeps the choice in the URL (`/settings?tab=policy&owner=acme`, `&repo=acme/widgets`), so a layer can be linked to; an organization's Settings tab and a repository's page link to their own. Picking one with no layer opens an empty one that its first save creates, and picking another while an edit is unsaved asks first. The document is a YAML text box: **Preview** runs the dry run and lists each key the text would change, before and after, with the text diff; **Save** then stores exactly the previewed text, with an optional reason. Both name the generation the edit started from (0 for a layer nobody wrote), so if someone else saved in between they are refused, the new version is read in and your text stays in the box to preview again. A layer lists above its text the keys it may set, per section. A refused document lists every problem next to the text, each with its key, and marks a key the layer may not set. When a save, its preview or an undo makes values of the layers under the document read as inherited (`layers_refused`), the tab lists them, each linked to its layer. Below it, **Values in effect** shows every key of every section with its value, its default and where it came from, and warns when a stored value is refused, an imported variable is still set, or the document holds a section or key this release does not know; for a layer, as that organization or repository reads it: the layer each value comes from, what the layer's own value overrides ("Overrides "09-18" from the deployment"), what it inherits and from whom, and, dimmed, the keys it may not set. **History** lists the document's revisions, opens each one to show what it changed, and offers Undo on the newest. Anyone signed in can read the tab, with the people behind changes shown as the audit log shows them (someone else's name only to an admin); only an admin can preview, save or undo, and an API key with a repository allowlist only on a repository's layer the list covers. A document [kept in a file](#from-a-file-the-command-line-and-mcp) is shown read-only, to an admin too.
 - **From the environment.** When a release moves a feature's policy into a section, the first start of that release imports each of its variables you set, when the value differs from the default, once per key (source `bootstrap`); a key a later release adds to the section is imported at that release's first start. A variable left at its default is not imported, so a default the section changes reaches every deployment that never set it; where a section turns a default the other way on purpose, it declares the value a deployment that relied on the old meaning keeps, and how to tell one from its records (for `leads.enabled`: a registered repository, a job or a lead a finder stored). Only records older than the moment the release first asked about the key count: the import records that moment once in the document's ledger (`leads.enabled@<time>`, the database's clock when the process began, before the migrations), so a repository a new deployment registers while it waits, or between two starts, is never taken for its past. While the variable is not set, such a deployment gets that value written into the document under a comment saying why (`settings_default_kept`, once); a new one does not, and a value an operator has written stands. If that check fails (the database busy at the start), its key reads its default, `settings_bootstrap_check_failed` is logged at error level, and the check is asked again in the same run, after a minute and then at doubling intervals up to fifteen minutes, until it answers (`settings_bootstrap_check_settled`); a restart in between asks at its start, about the same moment. An import that fails outright is tried again in the same run the same way. A part of a variable the section drops, such as an unknown finder name in `LEADS_FINDERS`, is named in a `settings_env_value_dropped` warning. A value the section refuses is skipped with a `settings_bootstrap_value_refused` warning: set it in the document instead. A value refused only together with the section's other stored values is held (`settings_bootstrap_value_held`) and tried again at the next start. After that the variable is ignored: startup logs `settings_env_ignored` and `embry0 config` says the document governs it. The variable is removed one release later. The reference below names the variable each key was imported from.
 - **After a rollback.** A section or a key that a newer release wrote and this one does not know is kept as long as it is sent back exactly as stored (as the stored text has it, or as GET's `data` does), and is listed in `unknown_sections` or `unknown_keys`.
-- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The two exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
+- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). And `slop_meter.bots` and `slop_meter.ai_agents` are lists each document adds to: a layer's items join those it inherits, and no layer takes one out (the reference marks them *added to*; `entries` names the document each item comes from). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
 - **Moved so far**, one section per bullet, in name order:
   - The asks policy (`asks`, from `ASKS_ENABLED` and the `ASK_*` variables): the ask loop reads it every tick and `GET /api/v1/asks/due` on every request, so turning asks on or changing their hours needs no restart. It is read per organization: an ask follows the layer of the organization its decision's repository belongs to for `hours`, `weekdays`, `timezone`, `remind_hours`, `expire_days` and `max_open_per_person`, and the deployment's document for the rest, so a change to an organization's layer applies to its asks on the next tick. An ask about a decision with no repository follows the deployment's document. `max_open_per_person` counts per person within an organization: someone asked about two organizations' decisions may hold each one's number, and the asks about decisions with no repository count apart. `enabled`, `lease_minutes` and `tick_seconds` are the deployment's alone.
   - Which repositories the background features read (`background`, from `SCOUT_REPOS`, `SCOUT_EXCLUDE`, `SLOP_METER_REPOS` and `SLOP_METER_EXCLUDE`, and what the scout and the Slop-O-Meter read before, into the repositories' layers): one switch per feature, `leads`, `scout` and `slop_meter`, which an organization's layer and a repository's layer may each set. A repository is read when it is registered, active and its switch resolves to true; nothing else enrolls it, not a job run on it. The scout and the meter are off until enrolled, and leads read every repository someone answers for unless a layer takes it out. Each loop reads it every tick, so opting a repository out stops it on the next one, and the meter removes what it kept of it `background.prune_after_days` (a week) later unless it comes back first ([which repositories](#which-repositories-background-features-read)).
@@ -318,7 +318,7 @@ asks:
   - The leads policy (`leads`, from `LEADS_ENABLED`, the other `LEADS_*` variables and `PROPOSALS_TICKET_MIN_READINESS`, which is `ask_min`, and `ask_severities`, until now fixed in the code: only a crack or a weed graded high or critical is asked in chat, which stays its default): the leads loop reads it every 5 minutes, and the proposals feed, decision cards, asks and the brief writer on every read, so turning leads on or changing what they read or ask needs no restart. `enabled` defaults to `false` now; a deployment that existed before keeps them on (*From the environment* above). An organization's layer may set the finders, the daily cap, `review_stale_days`, `flaky_commits`, both readiness thresholds and `ask_severities` for its repositories; the readiness labels and weights stay in the code until #168 moves them. What each kind of lead is called stays in the code: it is content, the lead-kind catalogue, not policy ([leads.md](leads.md#what-reaches-chat)).
   - The salvage policy (`salvage`, until now fixed in the code as `wip: unfinished — <agent> stopped (<reason>)`): the subject of the commit that keeps a stopped coding run's work, as a template naming `{agent}` and `{reason}`, so a repository whose commit rules refuse `wip:` can write what they accept. A subject past 100 characters has only its reason shortened. An organization's or a repository's layer may set it, and a coding job reads it when it starts, as it reads `done_when`.
   - The scout's policy (`scout`, from `SCOUT_TEMPLATES`, `SCOUT_MAX_IN_FLIGHT`, `SCOUT_REVISIT_HOURS` and `SCOUT_MAX_LEADS_PER_JOB`, plus each job's hard cap, until now fixed at 1 USD, and a daily cap, off by default): the scout reads it every tick, so a change applies within 5 minutes with no restart. Which repositories it reads is `background.scout` (above).
-  - The Slop-O-Meter's scoring policy and pace (`slop_meter`, from `SLOP_METER_INTERVAL_SECONDS`, which is `interval_hours`, or `enabled: false` for `0`, `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE`; everything else was fixed in the meter's code, and its defaults are those values, so a deployment that writes nothing scores exactly as before): what a changed line of each kind of file weighs (`weights`, merged glob by glob), which directories are vendored and what is a test, the hours a commit, a co-author or a comment implies, the lines an hour covers and the weekly cap, who counts as the core team and the small-repository rule, the outlier thresholds and what the judge is told, the five levels' bounds and names, and the owner's own bots and AI agents. An organization's layer may set every key but `enabled` and `interval_hours`, and a repository's what counts as code in its layout. Each organization's `slop_meter_bots` was copied into its layer as `bots` once; `PATCH /api/v1/orgs/{owner}` still takes it until 0.2.0. Every score records the version of the settings it was computed with, and the meter looks at the section every 5 minutes, so a change to what a score is computed from rescores the repositories it reaches at once rather than at the next daily run ([how a change rescores](slop-meter.md#how-a-change-rescores)). The variables left (`SLOP_METER_CATCHUP_SECONDS`, `_DATA_PATH`, `_GIT_TIMEOUT_SECONDS`, `_COMMITS_PER_TICK`, `_EVENT_PAGES`, `_REVIEWS_PER_TICK`, `_LOGINS_PER_TICK`, `_JUDGMENTS_PER_TICK`) are the process's own limits.
+  - The Slop-O-Meter's scoring policy and pace (`slop_meter`, from `SLOP_METER_INTERVAL_SECONDS`, which is `interval_hours`, or `enabled: false` for `0`, `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE`; everything else was fixed in the meter's code, and its defaults are those values, so a deployment that writes nothing scores exactly as before): what a changed line of each kind of file weighs (`weights`, merged glob by glob), which directories are vendored and what is a test, the hours a commit, a co-author or a comment implies, the lines an hour covers and the weekly cap, who counts as the core team and the small-repository rule, the outlier thresholds and what the judge is told, the five levels' bounds and names, and the owner's own bots and AI agents. An organization's layer may set every key but `enabled` and `interval_hours`, and a repository's what counts as code in its layout. Each organization's `slop_meter_bots` was copied into its layer as `bots` once, each bot once and an entry the section cannot hold left out; `PATCH /api/v1/orgs/{owner}` still takes it until 0.2.0. `bots` and `ai_agents` add to what a layer inherits. A credential's forge budget is the deployment's; an organization's `api_calls_per_tick` and `rate_reserve` only narrow its own share. Every score records the version of the settings it was computed with; every 5 minutes the meter compares it with the version each repository reads now and rescores only those that differ, from what it read, with no fetch and no forge call ([how a change rescores](slop-meter.md#how-a-change-rescores)). Until the first start's import has imported the three variables, the meter reads them as before. The variables left (`SLOP_METER_CATCHUP_SECONDS`, `_DATA_PATH`, `_GIT_TIMEOUT_SECONDS`, `_COMMITS_PER_TICK`, `_EVENT_PAGES`, `_REVIEWS_PER_TICK`, `_LOGINS_PER_TICK`, `_JUDGMENTS_PER_TICK`) are the process's own limits.
   - The dashboard's game layer and home page (`ui`, new: no variable configured them). The game is on and the guild is the home until a document says otherwise. The dashboard reads the section before it draws its navigation and home page, every minute after that and at once after a save on the Policy tab, and `GET /api/v1/config/ui` and the game's routes read it on every request, so turning the game off or on needs no restart and no reload. The deployment's only: the dashboard knows no viewer's organization to read a layer for. See [turning the game off](world.md#turning-the-game-off).
 
 ### Which repositories background features read
@@ -550,9 +550,9 @@ How the Slop-O-Meter weighs a changed line and a person's attention, where its l
 |---|---|---|---|---|---|---|
 | `enabled` | true or false | `true` |  |  | `SLOP_METER_INTERVAL_SECONDS` | The meter reads the repositories enrolled in background.slop_meter and scores them. false stops the reading and the scoring everywhere; what was kept of a repository that left the scope is still removed after background.prune_after_days. Was SLOP_METER_INTERVAL_SECONDS=0. The deployment's alone. |
 | `interval_hours` | number | `24.0` | ≥ 0.25, ≤ 8760 |  | `SLOP_METER_INTERVAL_SECONDS` | Hours between two runs over every enrolled repository: fetch, read the next part of its history and events, and rescore it once caught up. While a history is still being read the meter comes back sooner (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At least a quarter hour. Was SLOP_METER_INTERVAL_SECONDS. The deployment's alone. |
-| `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins. Where repositories of organizations that set different values are read with one credential, the smallest applies. Git fetches are not API calls. |
-| `rate_reserve` | whole number | `2000` | ≥ 0, ≤ 100000 | organization | `SLOP_METER_RATE_RESERVE` | The rate limit a credential keeps for the jobs that use it: once its remaining calls (X-RateLimit-Remaining) drop below this, the run makes no further call with it. Where organizations that set different values share one credential, the largest applies. |
-| `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the longest glob wins (*.min.js over *.js). Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting. |
+| `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins: the deployment's value is the credential's budget. An organization's value only narrows its own repositories' share of it, never widens it, and never lowers another organization's on the same credential. Git fetches are not API calls. |
+| `rate_reserve` | whole number | `2000` | ≥ 0, ≤ 100000 | organization | `SLOP_METER_RATE_RESERVE` | The rate limit a credential keeps for the jobs that use it: once its remaining calls (X-RateLimit-Remaining) drop below this, the run makes no further call with it. An organization's larger value stops only its own repositories' reads sooner; a smaller one changes nothing. |
+| `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the most specific wins: a glob with a '/' over any without one; between two with one, more segments free of wildcards, then more segments, then more literal characters; between two without, more literal characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every file under generated/, whatever its kind. Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting. |
 | `excluded_dirs` | list of text | `["vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files weigh nothing, each one name matched at any depth: vendored and third-party code. A list replaces the one it inherits whole; [] excludes none. |
 | `test_dirs` | list of text | `["__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample", "fixtures", "testdata"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files are tests or examples, each one name matched at any depth: their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
 | `test_files` | list of text | `["*_test.go", "*_test.py", "*_test.rb", "*_test.ex", "*_test.exs", "*_spec.rb", "test_?*.py"]` | at most 200 entries, each at most 200 characters | organization, repository |  | Globs of test and example files, in the grammar of weights (*_test.go, test_?*.py): their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
@@ -575,8 +575,8 @@ How the Slop-O-Meter weighs a changed line and a person's attention, where its l
 | `judge_prompt` | text | `"You judge one large commit of a software repository: did it add bulk code no\nperson wrote or reviewed line by line (slop, such as a large AI-generated\nchange), or is its size explained by something else (not slop: the project's\ninitial import, a code drop moved in from elsewhere, a restructuring that moved\nfiles, a vendored or generated library, a data or fixture dump)?\nJudge from what the message and the files say. When it is unclear, answer\nslop: false only if the files themselves look moved, vendored or generated."` | at least 1 characters, at most 4000 characters | organization |  | What the model judging an outlier commit is told slop is and is not. The answer's form (JSON with slop and a reason) is added after it. Applies to commits judged after it changes: a judgment is kept and never asked again, so a change rescores nothing. |
 | `level_bounds` | list of number | `[0.2, 0.4, 0.6, 0.8]` | at least 4 entries, at most 4 entries | organization |  | Where the five levels part: a score below the first bound is level 1, below the second level 2, and so on; at or above the last, level 5. Four bounds, each above the one before, from 0 to 1. |
 | `level_names` | list of text | `["Buttered Noodles", "Spaghetti Bolognese", "Lasagna", "Sloppy Joe", "Just The Slop"]` | at least 5 entries, at most 5 entries, each at most 60 characters | organization |  | The five levels' names, level 1 (the least slop) first. Each one line, each named once. |
-| `bots` | list of text | `[]` | at most 100 entries, each at most 200 characters | organization |  | The owner's own bots, as commit names, addresses or forge logins matched whole without regard to case: their commits add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit identities. Was the organization's slop_meter_bots. |
-| `ai_agents` | list of text | `[]` | at most 100 entries, each at most 200 characters | organization |  | AI coding agents beyond the known ones, as the start of their commit address (aider@), matched without regard to case: a commit one authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's hours. |
+| `bots` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | Bots, as commit names, addresses or forge logins matched whole without regard to case: their commits add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit identities. Each document adds to the list it inherits, so a bot the deployment lists counts for every organization; no layer takes one out. At most 200 in all. Was the organization's slop_meter_bots. |
+| `ai_agents` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | AI coding agents beyond the known ones, each its commit address up to and including the @ (aider@, any domain) or a whole address (agent@tools.example), matched without regard to case: a commit one authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's hours. Each document adds to the list it inherits, as bots. At most 200 in all. |
 
 #### `ui`
 
diff --git a/docs/examples/settings.yaml b/docs/examples/settings.yaml
index e6b0e0de..20e3fd4f 100644
--- a/docs/examples/settings.yaml
+++ b/docs/examples/settings.yaml
@@ -416,15 +416,17 @@ slop_meter:
   # interval_hours: 24.0
 
   # Forge API calls one run may make with one credential, shared round-robin
-  # by the repositories read with it, to read comments, reviews and logins.
-  # Where repositories of organizations that set different values are read
-  # with one credential, the smallest applies. Git fetches are not API calls.
+  # by the repositories read with it, to read comments, reviews and logins:
+  # the deployment's value is the credential's budget. An organization's value
+  # only narrows its own repositories' share of it, never widens it, and never
+  # lowers another organization's on the same credential. Git fetches are not
+  # API calls.
   # api_calls_per_tick: 200
 
   # The rate limit a credential keeps for the jobs that use it: once its
   # remaining calls (X-RateLimit-Remaining) drop below this, the run makes no
-  # further call with it. Where organizations that set different values share
-  # one credential, the largest applies.
+  # further call with it. An organization's larger value stops only its own
+  # repositories' reads sooner; a smaller one changes nothing.
   # rate_reserve: 2000
 
   # What one changed line of a file weighs, by glob, from 0 to 10; a file no
@@ -432,10 +434,15 @@ slop_meter:
   # with no '/' matches a file's name in any directory (*.py), one with a '/'
   # its path from the repository's root (db/migrations/*.sql, generated/**);
   # '*' matches within one name, '?' one character, '**' any directories.
-  # Where several match, the longest glob wins (*.min.js over *.js). Write
-  # globs in lowercase, quoted: matching ignores case, and YAML reads a bare *
-  # as an alias. Merged entry by entry: a document adds or changes the globs
-  # it names and keeps every other, so a glob set to 0 stops counting.
+  # Where several match, the most specific wins: a glob with a '/' over any
+  # without one; between two with one, more segments free of wildcards, then
+  # more segments, then more literal characters; between two without, more
+  # literal characters (*.min.js over *.js); then the first in alphabetical
+  # order. So generated/** weighs every file under generated/, whatever its
+  # kind. Write globs in lowercase, quoted: matching ignores case, and YAML
+  # reads a bare * as an alias. Merged entry by entry: a document adds or
+  # changes the globs it names and keeps every other, so a glob set to 0 stops
+  # counting.
   # weights:
   #   '*.py': 1.0
   #   '*.pyi': 1.0
@@ -670,18 +677,22 @@ slop_meter:
   # - Sloppy Joe
   # - Just The Slop
 
-  # The owner's own bots, as commit names, addresses or forge logins matched
-  # whole without regard to case: their commits add lines but no attention,
-  # and as a co-author they count as an AI agent does. Beyond the ones every
-  # deployment knows ([bot] accounts, noreply@ addresses, known coding agents)
-  # and embry0's own commit identities. Was the organization's
+  # Bots, as commit names, addresses or forge logins matched whole without
+  # regard to case: their commits add lines but no attention, and as a
+  # co-author they count as an AI agent does. Beyond the ones every deployment
+  # knows ([bot] accounts, noreply@ addresses, known coding agents) and
+  # embry0's own commit identities. Each document adds to the list it
+  # inherits, so a bot the deployment lists counts for every organization; no
+  # layer takes one out. At most 200 in all. Was the organization's
   # slop_meter_bots.
   # bots: []
 
-  # AI coding agents beyond the known ones, as the start of their commit
-  # address (aider@), matched without regard to case: a commit one authors
-  # adds lines but no attention, and one it co-authors counts
-  # ai_coauthor_share of its author's hours.
+  # AI coding agents beyond the known ones, each its commit address up to and
+  # including the @ (aider@, any domain) or a whole address
+  # (agent@tools.example), matched without regard to case: a commit one
+  # authors adds lines but no attention, and one it co-authors counts
+  # ai_coauthor_share of its author's hours. Each document adds to the list it
+  # inherits, as bots. At most 200 in all.
   # ai_agents: []
 
 # What the dashboard shows: the game layer, and the page it opens on.
diff --git a/docs/slop-meter.md b/docs/slop-meter.md
index 505289e8..3573c2d1 100644
--- a/docs/slop-meter.md
+++ b/docs/slop-meter.md
@@ -50,8 +50,8 @@ slop_meter:
 |---|---|---|
 | `enabled` | `true` | Whether the meter reads and scores at all. Off, it still removes what it kept of a repository that left its scope |
 | `interval_hours` | `24` | Hours between two runs over every enrolled repository, at least a quarter hour |
-| `api_calls_per_tick` | `200` | Forge API calls one run makes with one credential |
-| `rate_reserve` | `2000` | The rate limit a credential keeps for jobs: below it, the run calls the forge no more with it |
+| `api_calls_per_tick` | `200` | Forge API calls one run makes with one credential. An organization's value only narrows its own share |
+| `rate_reserve` | `2000` | The rate limit a credential keeps for jobs: below it, the run calls the forge no more with it. An organization's larger value stops only its own reads sooner |
 | `weights` | the published file types | What a changed line weighs, by glob, from 0 to 10 |
 | `excluded_dirs` | `vendor`, `node_modules`, `third_party`, `third-party`, `external`, `deps`, `bower_components` | Directories whose files weigh nothing |
 | `test_dirs` | `__tests__`, `tests`, `test`, `spec`, `specs`, `examples`, `example`, `demos`, `demo`, `samples`, `sample`, `fixtures`, `testdata` | Directories of tests and examples |
@@ -68,20 +68,38 @@ slop_meter:
 | `outlier_min_lines`, `outliers_per_year` | `2000`, `4` | Which commits are outliers |
 | `judge_prompt` | what the model is told slop is | The judge's guidance; the answer's form is added after it |
 | `level_bounds`, `level_names` | `[0.2, 0.4, 0.6, 0.8]`, the five names above | The levels |
-| `bots` | none | The owner's own bots, by commit name, address or forge login |
-| `ai_agents` | none | AI coding agents beyond the known ones, by the start of their commit address (`aider@`) |
+| `bots` | none | Bots, by commit name, address or forge login; each layer adds to the list it inherits |
+| `ai_agents` | none | AI coding agents beyond the known ones, by their commit address up to the `@` (`aider@`) or a whole address; each layer adds to the list |
 
-**Globs.** A glob with no `/` matches a file's name in any directory (`*.py`); one with a `/` matches its path from the repository's root (`db/migrations/*.sql`, `generated/**`). `*` matches within one name, `?` one character, `**` any number of directories. Matching ignores case, so globs are written in lowercase, and quoted in YAML, which reads a bare `*` as an alias. Where several globs of `weights` match a file, the longest wins (`*.min.js` over `*.js`), and between two of one length the first in alphabetical order. A file no glob matches weighs nothing.
+**Globs.** A glob with no `/` matches a file's name in any directory (`*.py`); one with a `/` matches its path from the repository's root (`db/migrations/*.sql`, `generated/**`). `*` matches within one name, `?` one character, `**` any number of directories. Matching ignores case, so globs are written in lowercase, and quoted in YAML, which reads a bare `*` as an alias. A file no glob matches weighs nothing. Where several globs of `weights` match a file, the most specific wins:
 
-**Layers.** An organization's layer may set every key but `enabled` and `interval_hours`, for its repositories: what counts as code, how fast its team attends to it, where its levels fall, its judge's guidance, its own bots and the forge budget of the credential it reads with. A repository's layer may set what counts as code in its own layout: `weights`, `excluded_dirs`, `test_dirs`, `test_files` and `test_marks`. `weights` is merged glob by glob, through every layer: a document adds or changes the globs it names and keeps every other, so a glob set to `0` stops counting. Every other key a layer sets replaces the inherited value whole. Where repositories of organizations that set different forge budgets are read with one credential, the fewest calls and the largest reserve apply, since the rate limit is the credential's.
+1. A glob with a `/` wins over any glob without one, so `generated/**: 0` weighs every file under `generated/` nothing, `.py`, `.proto` and `.graphql` alike.
+2. Between two globs with a `/`: the one with more segments free of wildcards (`src/legacy/**` over `src/**`), then the one with more segments, then the one with more literal characters (any but `*`, `?` and `/`).
+3. Between two globs without a `/`: the one with more literal characters (`*.min.js` over `*.js`).
+4. Any tie: the glob first in alphabetical order.
+
+The meter checks each path only against the globs that could match it (those under its first directory, those for its extension, and the few others) and weighs each path once a run.
+
+**Layers.** An organization's layer may set every key but `enabled` and `interval_hours`, for its repositories: what counts as code, how fast its team attends to it, where its levels fall, its judge's guidance, its own bots and a narrower forge budget. A repository's layer may set what counts as code in its own layout: `weights`, `excluded_dirs`, `test_dirs`, `test_files` and `test_marks`.
+
+- `weights` is merged glob by glob, through every layer: a document adds or changes the globs it names and keeps every other, so a glob set to `0` stops counting.
+- `bots` and `ai_agents` add to what a layer inherits: a bot the deployment lists counts for every organization, and no layer takes one out.
+- `excluded_dirs` and the `test_*` lists replace what they inherit whole, so a repository can take back a directory the default excludes (a `deps/` of its own code), restating the rest.
+- Every other key a layer sets replaces the inherited value.
+- **The forge budget.** A credential's budget is the deployment's `api_calls_per_tick` and `rate_reserve`. An organization's values only narrow its own repositories' share of it: fewer calls, or a larger reserve they stop at. They never widen it, and never lower what another organization reading with the same credential gets.
 
 **Before this section.** `SLOP_METER_INTERVAL_SECONDS` (`0` turned the reading off), `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE` are imported once, at the first start of the release that added the section, as `interval_hours` (or `enabled: false`), `api_calls_per_tick` and `rate_reserve`, and ignored after that. Each organization's `slop_meter_bots` was copied into its layer as `bots` ([api.md](api.md#organizations)). Everything else was a constant in the meter's code, and its default is that constant.
 
 ## How a change rescores
 
-Each score row records `config_version`: a digest of every key its repository's score is computed from, as that repository reads them through its organization's layer and its own. The meter looks at the section every five minutes. When a repository it read last reads another version (an operator changed a weight, a level, the pace, the bots), the meter runs at once, without waiting for `interval_hours`, rescores it and records the new version; undoing the change rescores it back. `GET /api/v1/repos/{repo}/-/slop-meter` shows the version of the repository's score in `reading.config_version` ([api.md](api.md)).
+Each score row records `config_version`: a digest of every key its repository's score is computed from, as that repository reads them through its organization's layer and its own. Every five minutes the meter compares each enrolled repository's stored version with the one it reads now. It rescores the repositories whose versions differ, and only those, from what it already read: no fetch, no forge call and no judgment, so a change costs a rescore of what it touches. The next full run keeps its time. Undoing a change rescores back the same way. `GET /api/v1/repos/{repo}/-/slop-meter` shows the version of the repository's score in `reading.config_version` ([api.md](api.md)).
+
+- A repository still reading its history is left to its catch-up, which scores it.
+- A rescore that fails is recorded on the repository and not tried again for that version.
+- An outlier commit a change makes new is judged at the next full run; until then the score is provisional.
+- A score stored before the version was recorded holds none, and a release that adds a key to what a score is computed from changes every digest. Either way the first run after the start, which scores every repository it reads, records the new versions.
 
-Four keys are not what a score is computed from, and change no version: `enabled`, `interval_hours`, `api_calls_per_tick` and `rate_reserve`. Neither does `judge_prompt`: a judgment is kept per commit and never asked again, so new guidance applies to the outlier commits judged after it, and a change to the weights that makes another commit an outlier has that one judged. A repository still reading its history is scored once it is caught up.
+Four keys are not what a score is computed from, and change no version: `enabled`, `interval_hours`, `api_calls_per_tick` and `rate_reserve`. Neither does `judge_prompt`: a judgment is kept per commit and never asked again, so new guidance applies to the outlier commits judged after it.
 
 ## Which repositories
 
@@ -89,7 +107,7 @@ The meter reads the registered, active repositories enrolled in it: `background.
 
 A repository that leaves the meter's scope, opted out or unregistered, loses its mirror and everything the meter kept of it `background.prune_after_days` (a week) later, unless it comes back first; one made inactive is not read and keeps what was read ([what it keeps](#what-it-keeps)).
 
-The loop is on by default and reads what is enrolled. `slop_meter.enabled: false` turns the reading off; turned on again, the meter reads within five minutes.
+The loop is on by default and reads what is enrolled. `slop_meter.enabled: false` turns the reading off; turned on again, the meter reads within five minutes. Until the first start's import has imported `SLOP_METER_INTERVAL_SECONDS`, `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE` (a start whose import failed: it is tried again while the orchestrator runs), the meter reads them as the release before did, so a meter that was off stays off (`slop_meter_settings_not_imported`).
 
 ## What it reads, and how much
 
diff --git a/embry0/api/app.py b/embry0/api/app.py
index 73f54260..2f88c469 100644
--- a/embry0/api/app.py
+++ b/embry0/api/app.py
@@ -2739,7 +2739,7 @@ async def _slop_meter_bots(repo: str) -> list[str]:
         # background_scope_exits, each removal audited); the enrollment, the judge's model
         # (background_models.slop_judge) and the slop_meter section come from one snapshot a tick.
         repos=registry_reader(app.state.repos_repo),
-        read=meter_reader(app.state.settings),
+        read=meter_reader(app.state.settings, config),
         store=app.state.slop_meter_repo,
         mirror=GitMirror(_Path(config.slop_meter_data_path), timeout=config.slop_meter_git_timeout_seconds),
         exits=ScopeExitsRepository(db),
diff --git a/embry0/api/v1/organizations.py b/embry0/api/v1/organizations.py
index 332a9298..a1c1e9e5 100644
--- a/embry0/api/v1/organizations.py
+++ b/embry0/api/v1/organizations.py
@@ -171,8 +171,34 @@ async def probe_access(request: Request, owner: str, forge: str, token: str) ->
 
 
 def _split_moved(settings: dict[str, Any]) -> dict[str, Any]:
-    """Take the settings that moved into the settings document out of ``settings``, and return them."""
-    return {key: settings.pop(key) for key in list(settings) if key in org_service.MOVED}
+    """Take the settings that moved into the settings document out of ``settings``, and return them, each as it is
+    written into the organization's layer (:attr:`embry0.services.organizations.MovedSetting.write`)."""
+    moved = {key: settings.pop(key) for key in list(settings) if key in org_service.MOVED}
+    for key, value in moved.items():
+        write = org_service.MOVED[key].write
+        if write is not None and value is not None:
+            moved[key] = write(value)
+    return moved
+
+
+def _refuse_moved(moved: dict[str, Any]) -> None:
+    """Refuse, with 422 and before anything is stored, a moved setting its section would refuse as a layer's own
+    value: so ``POST /orgs`` never registers an owner and then refuses the layer it writes."""
+    from embry0.settings.registry import SectionRefused
+    from embry0.settings.sections import CATALOG
+
+    problems: list[str] = []
+    for key, value in moved.items():
+        target = org_service.MOVED[key]
+        section = CATALOG.get(target.section)
+        if section is None or value is None:
+            continue
+        try:
+            section.validate_alone({target.key: value})
+        except SectionRefused as exc:
+            problems.extend(f"{key}: {error.get('msg')}" for error in exc.errors)
+    if problems:
+        raise HTTPException(status_code=422, detail="; ".join(problems))
 
 
 async def _write_moved(request: Request, owner: str, moved: dict[str, Any]) -> list[dict[str, Any]]:
@@ -345,6 +371,7 @@ async def register_organization(body: OrganizationBody, request: Request) -> dic
     if moved:
         # Refused before anything is stored: the organization's layer takes a key without an allowlist.
         await enforce_repo_allowlist(request, None, action="change the settings document")
+        _refuse_moved(moved)
     access: dict[str, Any] = {}
     repo_count: int | None = None
     if body.probe:
diff --git a/embry0/services/organizations.py b/embry0/services/organizations.py
index bf8e1c2b..81831205 100644
--- a/embry0/services/organizations.py
+++ b/embry0/services/organizations.py
@@ -11,6 +11,7 @@
 from __future__ import annotations
 
 import math
+import unicodedata
 from collections.abc import Callable, Mapping
 from dataclasses import dataclass, field
 from datetime import datetime
@@ -19,6 +20,8 @@
 
 import structlog
 
+from embry0.settings.registry import UNPRINTABLE_CATEGORIES
+
 logger = structlog.get_logger(__name__)
 
 FORGES = ("github", "gitlab")
@@ -176,6 +179,8 @@ class MovedSetting:
     section: str
     key: str
     read: Callable[[Mapping[str, Any]], Any]
+    #: How a value the routes still take is written into the layer; None writes it as checked.
+    write: Callable[[Any], Any] | None = None
 
     @property
     def path(self) -> str:
@@ -201,22 +206,50 @@ def context_audit_open_prs_moved(settings: Mapping[str, Any]) -> bool | None:
     return True if context_audit_open_prs(settings) else None
 
 
+def _bots_cleaned(value: Any) -> list[str] | None:
+    """A ``slop_meter_bots`` value as the ``slop_meter`` section takes it: each string, stripped, blanks left out,
+    each named once without regard to case (the first spelling kept), as matching ignored case. An entry the
+    section would refuse (longer than an entry may be, or holding a line break, a tab, a control, format or
+    separator character) is left out and logged, by its position, never its text, so it never costs the rest;
+    so is every entry past the most a list holds. None for a value that is no list."""
+    if not isinstance(value, list):
+        return None
+    seen: dict[str, str] = {}
+    dropped: list[int] = []
+    for position, entry in enumerate(value, start=1):
+        text = entry.strip() if isinstance(entry, str) else ""
+        if not text:
+            continue
+        if len(text) > LIST_MAX_LENGTH or any(unicodedata.category(char) in UNPRINTABLE_CATEGORIES for char in text):
+            dropped.append(position)
+            continue
+        seen.setdefault(text.lower(), text)
+    kept = list(seen.values())
+    if len(kept) > LIST_MAX_ITEMS or dropped:
+        logger.warning(
+            "slop_meter_bots_entries_dropped",
+            positions=dropped,
+            past_the_most=max(0, len(kept) - LIST_MAX_ITEMS),
+            hint="left out of slop_meter.bots: an entry the section cannot hold",
+        )
+    return kept[:LIST_MAX_ITEMS]
+
+
 def slop_meter_bots(settings: Mapping[str, Any]) -> list[str] | None:
-    """The owner's ``slop_meter_bots`` as the meter read them (#184): each string, stripped, blanks left out, and
-    each named once without regard to case (the first spelling kept), as matching ignored case; None for none.
+    """The owner's ``slop_meter_bots`` as the meter read them (#184), cleaned as :func:`_bots_cleaned` cleans a
+    list; None for none, so nothing is copied.
 
     A row written before ``POST /orgs`` checked its settings may hold anything
     here, so a value that is no list reads as none, as it did.
     """
-    value = settings.get("slop_meter_bots")
-    if not isinstance(value, list):
-        return None
-    seen: dict[str, str] = {}
-    for entry in value:
-        text = entry.strip() if isinstance(entry, str) else ""
-        if text:
-            seen.setdefault(text.lower(), text)
-    return list(seen.values()) or None
+    return _bots_cleaned(settings.get("slop_meter_bots")) or None
+
+
+def slop_meter_bots_written(value: Any) -> list[str]:
+    """A ``slop_meter_bots`` value ``PATCH`` or ``POST /orgs`` takes, as it is written into the organization's
+    layer: cleaned as the copy at the first start cleans one, so a list the route took before is never refused
+    for spelling one bot twice. An empty list stays, and takes the organization's own bots out."""
+    return _bots_cleaned(value) or []
 
 
 #: The settings sections took over: an organization's own caps of its context audits, which the `budget`
@@ -229,7 +262,7 @@ def slop_meter_bots(settings: Mapping[str, Any]) -> list[str] | None:
     ),
     MovedSetting("context_audit_days", "context_audit", "days", context_audit_days),
     MovedSetting("context_audit_open_prs", "context_audit", "open_prs", context_audit_open_prs_moved),
-    MovedSetting("slop_meter_bots", "slop_meter", "bots", slop_meter_bots),
+    MovedSetting("slop_meter_bots", "slop_meter", "bots", slop_meter_bots, slop_meter_bots_written),
 )
 MOVED: Final[dict[str, MovedSetting]] = {moved.legacy: moved for moved in MOVED_SETTINGS}
 
diff --git a/embry0/services/slop_meter/events.py b/embry0/services/slop_meter/events.py
index dcd83462..7315d3f6 100644
--- a/embry0/services/slop_meter/events.py
+++ b/embry0/services/slop_meter/events.py
@@ -78,6 +78,38 @@ async def get(self, client: Any, path: str, **kwargs: Any) -> Any:
         return response
 
 
+class ShareBudget:
+    """One organization's share of a credential's :class:`ApiBudget` for the tick (#169).
+
+    At most ``calls`` of the credential's calls, stopping once the credential's
+    remaining rate limit is below ``reserve``; and never past the credential's
+    own budget or reserve, which every share of it draws on. A share narrower
+    than the credential's ends only its own organization's reads.
+    """
+
+    def __init__(self, shared: ApiBudget, *, calls: int, reserve: int) -> None:
+        self.shared = shared
+        self.left = max(0, calls)
+        self.reserve = reserve
+        self.made = 0
+
+    @property
+    def remaining(self) -> int | None:
+        return self.shared.remaining
+
+    @property
+    def spent(self) -> bool:
+        remaining = self.shared.remaining
+        return self.left <= 0 or self.shared.spent or (remaining is not None and remaining < self.reserve)
+
+    async def get(self, client: Any, path: str, **kwargs: Any) -> Any:
+        if self.spent:
+            raise BudgetSpent
+        self.left -= 1
+        self.made += 1
+        return await self.shared.get(client, path, **kwargs)
+
+
 @dataclass
 class EventBatch:
     #: (id, kind, login, at)
@@ -156,7 +188,7 @@ def __init__(
     def done(self) -> bool:
         return self._stage >= 5
 
-    async def step(self, budget: ApiBudget) -> bool:
+    async def step(self, budget: ApiBudget | ShareBudget) -> bool:
         """Make the next call; False when there is nothing left to read. Raises BudgetSpent with the budget gone."""
         if self._stage <= 1:
             await self._listing_page(budget)
@@ -174,7 +206,9 @@ def _advance(self) -> None:
         self._stage += 1
         self._next, self._pages = None, 0
 
-    async def _page(self, budget: ApiBudget, path: str, params: dict[str, Any]) -> tuple[list[Any], bool, bool]:
+    async def _page(
+        self, budget: ApiBudget | ShareBudget, path: str, params: dict[str, Any]
+    ) -> tuple[list[Any], bool, bool]:
         """One page of a listing: its items, whether to read the next one, and whether the listing ended.
 
         A listing cut at the page cap, or answered with an error, has not ended
@@ -196,7 +230,7 @@ async def _page(self, budget: ApiBudget, path: str, params: dict[str, Any]) -> t
             return (body if isinstance(body, list) else []), False, False
         return (body if isinstance(body, list) else []), bool(self._next), not self._next
 
-    async def _listing_page(self, budget: ApiBudget) -> None:
+    async def _listing_page(self, budget: ApiBudget | ShareBudget) -> None:
         name, kind, prefix, cursor = _LISTINGS[self._stage]
         since: datetime | None = getattr(self.batch, cursor)
         params: dict[str, Any] = {"sort": "updated", "direction": "asc"}
@@ -210,7 +244,7 @@ async def _listing_page(self, budget: ApiBudget) -> None:
         if not go_on:
             self._advance()
 
-    async def _pulls_page(self, budget: ApiBudget) -> None:
+    async def _pulls_page(self, budget: ApiBudget | ShareBudget) -> None:
         items, has_next, _ended = await self._page(
             budget, f"/repos/{self._repo}/pulls", {"state": "all", "sort": "updated", "direction": "desc"}
         )
@@ -230,7 +264,7 @@ async def _pulls_page(self, budget: ApiBudget) -> None:
             self._pulls.sort()
             self._advance()
 
-    async def _reviews(self, budget: ApiBudget) -> None:
+    async def _reviews(self, budget: ApiBudget | ShareBudget) -> None:
         if not self._pulls or self._max_pulls <= 0:
             if self._pulls:
                 self.batch.more = True
@@ -248,7 +282,7 @@ async def _reviews(self, budget: ApiBudget) -> None:
         if not self._pulls:
             self._advance()
 
-    async def _login(self, budget: ApiBudget) -> None:
+    async def _login(self, budget: ApiBudget | ShareBudget) -> None:
         if self._logins is None:
             named = self._stored | {login.lower() for _id, _kind, login, _at in self.batch.events}
             missing = sorted(n for n in named if n not in self._known and not is_bot(n, ""))
diff --git a/embry0/services/slop_meter/globs.py b/embry0/services/slop_meter/globs.py
index b3913455..fbae4f54 100644
--- a/embry0/services/slop_meter/globs.py
+++ b/embry0/services/slop_meter/globs.py
@@ -22,6 +22,7 @@
 
 import functools
 import re
+from collections.abc import Iterable
 from typing import Final
 
 MAX_GLOB_LENGTH: Final = 200
@@ -130,3 +131,102 @@ def marked(name: str, marks: frozenset[str]) -> bool:
         return False
     word = stem.rpartition(".")[2]
     return bool(stem) and "." in stem and word in marks
+
+
+def specificity(glob: str) -> tuple[int, int, int, int]:
+    """How specific ``glob`` is, larger the more specific; where several globs match one file, the most specific
+    is the one that counts (:class:`GlobIndex`).
+
+    A glob with a ``/`` is more specific than any glob without one. Between two
+    with a ``/``: the one with more segments free of wildcards, then the one with
+    more segments, then the one with more literal characters. Between two
+    without: the one with more literal characters, so ``*.min.js`` is more
+    specific than ``*.js``. A literal character is any but ``*``, ``?`` and ``/``.
+    """
+    lowered = glob.lower()
+    literal = sum(1 for char in lowered if char not in "*?/")
+    if "/" not in lowered:
+        return (0, literal, 0, 0)
+    segments = lowered.split("/")
+    plain = sum(1 for segment in segments if not any(char in segment for char in "*?"))
+    return (1, plain, len(segments), literal)
+
+
+#: A glob's place among others: :func:`specificity`, the most specific first, then the glob's text.
+_Order = tuple[tuple[int, ...], str]
+
+
+def _order(glob: str) -> _Order:
+    """Sorts the most specific glob first; between two of one specificity, the first in alphabetical order."""
+    return tuple(-part for part in specificity(glob)), glob.lower()
+
+
+class GlobIndex[V]:
+    """Globs, each with a value, indexed so a path is checked against the few that could match it.
+
+    :meth:`best` answers the value of the most specific glob that matches a
+    path (:func:`specificity`; a tie goes to the glob first in alphabetical
+    order), or None. A glob ``*`` and a literal holding a ``.`` (``*.py``,
+    ``*_test.go``) is filed under its last extension and checked only against
+    names with that extension; a glob with no wildcard against the one name it
+    is; a glob with a ``/`` whose first segment is a name only against paths
+    under that directory. ``evaluations`` counts the globs checked.
+    """
+
+    def __init__(self, entries: Iterable[tuple[str, V]]) -> None:
+        self._exact: dict[str, tuple[_Order, V]] = {}
+        self._by_extension: dict[str, list[tuple[_Order, str, V]]] = {}
+        self._names: list[tuple[_Order, re.Pattern[str], V]] = []
+        self._by_head: dict[str, list[tuple[_Order, re.Pattern[str], V]]] = {}
+        self._paths: list[tuple[_Order, re.Pattern[str], V]] = []
+        self.evaluations = 0
+        for glob, value in sorted(entries, key=lambda entry: _order(entry[0])):
+            lowered = glob.lower()
+            order = _order(lowered)
+            if "/" in lowered:
+                head = lowered.split("/", 1)[0]
+                wild = any(char in head for char in "*?")
+                target = self._paths if wild else self._by_head.setdefault(head, [])
+                target.append((order, compile_glob(lowered), value))
+            elif not any(char in lowered for char in "*?"):
+                self._exact.setdefault(lowered, (order, value))
+            elif lowered.startswith("*") and "." in lowered and not any(char in lowered[1:] for char in "*?"):
+                extension = lowered.rpartition(".")[2]
+                self._by_extension.setdefault(extension, []).append((order, lowered[1:], value))
+            else:
+                self._names.append((order, compile_glob(lowered), value))
+
+    def _first(self, candidates: Iterable[tuple[_Order, re.Pattern[str], V]], text: str) -> tuple[_Order, V] | None:
+        for order, pattern, value in candidates:
+            self.evaluations += 1
+            if pattern.fullmatch(text) is not None:
+                return order, value
+        return None
+
+    def best(self, path: str) -> V | None:
+        """The value of the most specific glob matching ``path``, lowercased and from the repository's root."""
+        found: list[tuple[_Order, V]] = []
+        if "/" in path:
+            hit = self._first(self._by_head.get(path.split("/", 1)[0], ()), path)
+            if hit is not None:
+                found.append(hit)
+        hit = self._first(self._paths, path)
+        if hit is not None:
+            found.append(hit)
+        if not found:
+            # Only when no glob with a '/' matches: any of them is more specific than every glob without one.
+            name = path.rsplit("/", 1)[-1]
+            exact = self._exact.get(name)
+            if exact is not None:
+                self.evaluations += 1
+                found.append(exact)
+            if "." in name:
+                for order, suffix, value in self._by_extension.get(name.rpartition(".")[2], ()):
+                    self.evaluations += 1
+                    if name.endswith(suffix):
+                        found.append((order, value))
+                        break
+            hit = self._first(self._names, name)
+            if hit is not None:
+                found.append(hit)
+        return min(found, key=lambda item: item[0])[1] if found else None
diff --git a/embry0/services/slop_meter/history.py b/embry0/services/slop_meter/history.py
index 585b2683..5fb31e97 100644
--- a/embry0/services/slop_meter/history.py
+++ b/embry0/services/slop_meter/history.py
@@ -76,13 +76,14 @@
 def is_bot(name: str, email: str, bots: frozenset[str] | None = None, agents: Iterable[str] = ()) -> bool:
     """A bot or an AI coding agent: a known name, a ``[bot]`` name or address, ``noreply@``, an agent's address,
     a name, address or login in ``bots`` (:func:`own_identities`; embry0's own when none is given), or an
-    address that starts with one of ``agents`` (the ``slop_meter`` section's ``ai_agents``, lowercased)."""
+    address one of ``agents`` names (the ``slop_meter`` section's ``ai_agents``, lowercased): one ending in
+    ``@`` names every address that starts with it, any other the whole address."""
     name, email = name.strip().lower(), email.strip().lower()
     if name in KNOWN_BOTS or name.endswith("[bot]"):
         return True
     if email.endswith("[bot]@users.noreply.github.com") or email.startswith(("noreply@", *_AI_EMAIL_PREFIXES)):
         return True
-    if email and any(email.startswith(prefix) for prefix in agents):
+    if email and any(email.startswith(a) if a.endswith("@") else email == a for a in agents):
         return True
     own = _embry0_identities() if bots is None else bots
     return name in own or email in own
@@ -112,12 +113,13 @@ def _embry0_identities() -> frozenset[str]:
 
 
 def agent_prefixes(agents: Iterable[str]) -> tuple[str, ...]:
-    """The ``slop_meter`` section's ``ai_agents`` as :func:`is_bot` matches them: lowercased, blanks dropped."""
+    """The ``slop_meter`` section's ``ai_agents`` as :func:`is_bot` matches them: lowercased, blanks dropped,
+    each once."""
     return tuple(dict.fromkeys(a.strip().lower() for a in agents if a.strip()))
 
 
 def with_bots(commits: Sequence[Commit], bots: frozenset[str], agents: Iterable[str] = ()) -> list[Commit]:
-    """``commits`` as they read with ``bots`` and the AI agents' address prefixes ``agents`` known: a listed
+    """``commits`` as they read with ``bots`` and the AI agents ``agents`` (:func:`is_bot`) known: a listed
     author's commit is a bot's, and a listed co-author co-wrote as an agent does, not as a person. Rows read
     before an identity was listed are corrected here, when scored, without reading the history again."""
     prefixes = agent_prefixes(agents)
diff --git a/embry0/services/slop_meter/loop.py b/embry0/services/slop_meter/loop.py
index 5e057c1e..5ee54f9d 100644
--- a/embry0/services/slop_meter/loop.py
+++ b/embry0/services/slop_meter/loop.py
@@ -22,9 +22,11 @@
 and scores each repository with the section as that repository reads it
 (#169). Each score records the section's :func:`config_version` for it. The
 schedule looks at the settings every :data:`LOOK_SECONDS`, so turning the
-meter on or off, or a new interval, applies within them, and a change to what
-a repository's score is computed from runs the next tick at once instead of
-at its next interval: the change rescores on the next run.
+meter on or off, or a new interval, applies within them. Between runs, each
+look compares every repository's stored version with the one it reads now and
+rescores only the repositories whose versions differ, from what was read,
+with no fetch and no forge call (:meth:`SlopMeterLoop.rescore_changed`): a
+change rescores what it touches at once, and the next run keeps its time.
 """
 
 from __future__ import annotations
@@ -42,7 +44,7 @@
 from embry0.services.areas import AREAS_PATH, area_of_path, parse_areas
 from embry0.services.background_models import BackgroundCallRefused, BackgroundCalls, ModelLookup, model_lookup
 from embry0.services.background_scope import Enrollment, Registered, enrollment
-from embry0.services.slop_meter.events import ApiBudget, BudgetSpent, EventReader
+from embry0.services.slop_meter.events import ApiBudget, BudgetSpent, EventReader, ShareBudget
 from embry0.services.slop_meter.history import (
     HISTORY_VERSION,
     Commit,
@@ -55,7 +57,7 @@
 )
 from embry0.services.slop_meter.judge import FEATURE
 from embry0.services.slop_meter.prune import Audit, PruneOutcome, Pruner
-from embry0.services.slop_meter.score import DEFAULTS, Event, Meter, meters, outliers
+from embry0.services.slop_meter.score import DEFAULTS, Event, Meter, Outlier, meters, outliers
 from embry0.services.slop_meter.weights import CONFIG_FILES, FileRules, Weigher, ignore_patterns, outlier_files
 from embry0.settings.layers import PerRepository
 from embry0.settings.sections.slop_meter import SLOP_METER, SlopMeterSettings, config_version
@@ -122,17 +124,69 @@ class MeterRead:
     meter: PerRepository[SlopMeterSettings] = field(default_factory=_Defaults)
 
 
-def meter_reader(store: Any) -> Callable[[], Awaitable[MeterRead]]:
+@dataclass(frozen=True)
+class _NotImported:
+    """The ``slop_meter`` section with the keys the import has not imported read from their variables, as the
+    release before read them (``legacy``), where no layer sets them."""
+
+    scoped: Any
+    legacy: Mapping[str, Any]
+
+    def deployment(self) -> SlopMeterSettings:
+        model: SlopMeterSettings = self.scoped.deployment()
+        return model.model_copy(update=dict(self.legacy))
+
+    def repo(self, repo: str | None) -> SlopMeterSettings:
+        resolved = self.scoped.snapshot.resolve(SLOP_METER, repo=repo)
+        own = {key for values in resolved.applied.values() for key in values}
+        updates = {key: value for key, value in self.legacy.items() if key not in own}
+        model: SlopMeterSettings = resolved.model
+        return model.model_copy(update=updates) if updates else model
+
+
+def not_imported(snapshot: Any, config: Any) -> dict[str, Any]:
+    """The keys of the ``slop_meter`` section the environment import has not imported into the deployment's
+    document (a first start whose import failed) and that it does not set, each with its variable's value as the
+    import would read it; a variable not set is left out, so its key reads its default, as it did."""
+    from embry0.settings.bootstrap import env_value
+    from embry0.settings.document import mapping
+
+    stored = mapping(snapshot.data.get(SLOP_METER.name))
+    out: dict[str, Any] = {}
+    for key in SLOP_METER.imports():
+        if snapshot.imported(f"{SLOP_METER.name}.{key}") or key in stored:
+            continue
+        value = env_value(SLOP_METER, key, config)
+        if value is not None:
+            out[key] = value
+    return out
+
+
+def meter_reader(store: Any, config: Any = None) -> Callable[[], Awaitable[MeterRead]]:
     """The reader the meter is built with: each call takes one snapshot of the settings documents
-    (``store.snapshot()``) and reads the judge's model, the enrollment and the ``slop_meter`` section from it."""
+    (``store.snapshot()``) and reads the judge's model, the enrollment and the ``slop_meter`` section from it.
+
+    With ``config``, a key the environment import has not imported yet reads
+    its variable, as the budget's readers do (#171): a deployment that had the
+    meter off keeps it off until the import, which the budget policy tries
+    again while it runs, succeeds (``slop_meter_settings_not_imported``).
+    """
+    logged: set[str] = set()
 
     async def read() -> MeterRead:
         snapshot = await store.snapshot()
-        return MeterRead(
-            models=model_lookup(snapshot, "slop_judge"),
-            enrollment=enrollment(snapshot),
-            meter=snapshot.scoped(SLOP_METER),
-        )
+        meter: PerRepository[SlopMeterSettings] = snapshot.scoped(SLOP_METER)
+        legacy = not_imported(snapshot, config) if config is not None else {}
+        if legacy:
+            meter = _NotImported(meter, legacy)
+            if set(legacy) - logged:
+                logged.update(legacy)
+                logger.error(
+                    "slop_meter_settings_not_imported",
+                    keys=sorted(f"{SLOP_METER.name}.{key}" for key in legacy),
+                    hint="read from their variables, as the release before read them, until the import succeeds",
+                )
+        return MeterRead(models=model_lookup(snapshot, "slop_judge"), enrollment=enrollment(snapshot), meter=meter)
 
     return read
 
@@ -148,14 +202,19 @@ class Inputs:
     files: dict[str, str | None]
     #: The ``slop_meter`` section as the repository reads it.
     settings: SlopMeterSettings = DEFAULTS
+    #: Its file rules, built once for one score (they keep each path's weight); None builds them.
+    rules: FileRules | None = None
 
 
 def weigher_for(
-    commits: Iterable[Commit], files: Mapping[str, str | None], settings: SlopMeterSettings = DEFAULTS
+    commits: Iterable[Commit],
+    files: Mapping[str, str | None],
+    settings: SlopMeterSettings = DEFAULTS,
+    rules: FileRules | None = None,
 ) -> Weigher:
     """The repository's line weights: its ``slop_meter`` file rules, its linters' ignore lists, and its
     outlier files."""
-    rules = FileRules.of(settings)
+    rules = rules if rules is not None else FileRules.of(settings)
     base = Weigher(ignore_patterns(files), rules=rules)
     sizes: dict[str, int] = {}
     for c in commits:
@@ -182,7 +241,7 @@ def logins_from(commits: Iterable[Commit], looked_up: Mapping[str, str]) -> dict
 def compute(inputs: Inputs) -> dict[str, Meter]:
     """The repository's meter (``""``) and its areas', from the history as read, scored with ``inputs.settings``.
     Pure: runs in a thread."""
-    weigh = weigher_for(inputs.commits, inputs.files, inputs.settings)
+    weigh = weigher_for(inputs.commits, inputs.files, inputs.settings, inputs.rules)
     areas = parse_areas(inputs.files.get(AREAS_PATH))
 
     def area_of(path: str) -> str | None:
@@ -195,6 +254,12 @@ def area_of(path: str) -> str | None:
     )
 
 
+def unjudged(inputs: Inputs) -> list[Outlier]:
+    """The repository's outlier commits no model has judged yet. Pure: runs in a thread."""
+    weigh = weigher_for(inputs.commits, inputs.files, inputs.settings, inputs.rules)
+    return [o for o in outliers(inputs.commits, weigh, inputs.judgments, inputs.settings) if o.slop is None]
+
+
 TokenFor = Callable[[str], Awaitable[tuple[str, str, str] | None]]
 ClientFor = Callable[[str], Awaitable[Any]]
 
@@ -309,9 +374,10 @@ def __init__(
         self._backlog = False
         #: Whether the last look found the meter on; None before the first.
         self._enabled: bool | None = None
-        #: Each repository the last run read, with the configuration version it read it with: a look that finds
-        #: one of them reading another version runs the next tick at once.
-        self._versions: dict[str, str] = {}
+        #: Each repository's configuration version as this process last scored it, or tried to: a look rescores a
+        #: repository whose stored score has another version only once per version, so one whose rescoring fails
+        #: is not tried again every look.
+        self._tried: dict[str, str] = {}
 
     @property
     def last_pass(self) -> datetime | None:
@@ -339,7 +405,6 @@ async def tick(self, read: MeterRead | None = None) -> bool:
         await self._respell(registered.every)
         await self._prune(read, registered)
         names = read.enrollment.scope(SCOPE, registered.active)
-        self._versions = {repo: config_version(read.meter.repo(repo)) for repo in names}
         if not names:
             return False
         self._lookup = read.models
@@ -464,15 +529,19 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
         """Every GitHub repository's events, one API call per repository in turn.
 
         Repositories read with one credential share its budget for the tick:
-        ``slop_meter.api_calls_per_tick`` calls, stopping at its rate limit's
-        ``rate_reserve``, each as the repository's organization reads them;
-        where organizations that read with one credential set different
-        values, the fewest calls and the largest reserve apply, since the rate
-        limit is the credential's. One credential running low never stops a
-        repository read with another (#185).
+        the deployment's ``slop_meter.api_calls_per_tick`` calls, stopping at
+        its rate limit's ``rate_reserve``. An organization's own values only
+        narrow its own share of that budget (:class:`ShareBudget`): fewer calls
+        for its repositories, or a larger reserve they stop at, never more,
+        and never less for another organization's repositories on the same
+        credential. One credential running low never stops a repository read
+        with another (#185).
         """
+        deployment = self._meter.deployment()
         readers: dict[str, EventReader] = {}
-        bounds: dict[str, tuple[int, int]] = {}
+        budgets: dict[str, ApiBudget] = {}
+        shares: dict[tuple[str, str], ShareBudget] = {}
+        share_of: dict[str, ShareBudget] = {}
         for repo in order:
             if repo in work and work[repo].forge == "github":
                 try:
@@ -482,21 +551,27 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                     continue
                 if reader is not None:
                     readers[repo] = reader
-                    own = self._meter.repo(repo)
-                    calls, reserve = bounds.get(work[repo].credential, (own.api_calls_per_tick, own.rate_reserve))
-                    bounds[work[repo].credential] = (
-                        min(calls, own.api_calls_per_tick),
-                        max(reserve, own.rate_reserve),
+                    credential = work[repo].credential
+                    shared = budgets.setdefault(
+                        credential, ApiBudget(deployment.api_calls_per_tick, deployment.rate_reserve)
                     )
-        budgets = {credential: ApiBudget(calls, reserve) for credential, (calls, reserve) in bounds.items()}
+                    owner = repo.split("/", 1)[0].lower()
+                    if (credential, owner) not in shares:
+                        own = self._meter.repo(repo)
+                        shares[(credential, owner)] = ShareBudget(
+                            shared,
+                            calls=min(own.api_calls_per_tick, deployment.api_calls_per_tick),
+                            reserve=max(own.rate_reserve, deployment.rate_reserve),
+                        )
+                    share_of[repo] = shares[(credential, owner)]
         active = list(readers)
         waiting: list[str] = []
         while active:
             for repo in list(active):
                 try:
-                    going = await readers[repo].step(budgets[work[repo].credential])
+                    going = await readers[repo].step(share_of[repo])
                 except BudgetSpent:
-                    # Its credential's budget is gone; the others' repositories go on.
+                    # Its share of its credential's budget is gone; the others' repositories go on.
                     active.remove(repo)
                     waiting.append(repo)
                     continue
@@ -507,7 +582,7 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                 if not going:
                     active.remove(repo)
         if waiting:
-            spent = [b for b in budgets.values() if b.spent]
+            spent = [b for b in shares.values() if b.spent]
             logger.info(
                 "slop_meter_api_budget_spent",
                 calls=[b.made for b in spent],
@@ -539,14 +614,24 @@ async def _inputs(self, repo: str, settings: SlopMeterSettings) -> Inputs:
             if not is_bot(str(e["login"]), "", bots, agents)
         ]
         files = {name: await self._mirror.read(repo, name) for name in (*CONFIG_FILES, AREAS_PATH)}
-        return Inputs(commits, events, await self._store.logins(), await self._store.judgments(repo), files, settings)
+        logins, judgments = await self._store.logins(), await self._store.judgments(repo)
+        return Inputs(commits, events, logins, judgments, files, settings, FileRules.of(settings))
 
-    async def _score(self, repo: str) -> None:
-        """Score ``repo`` with the ``slop_meter`` section as it reads it, recording that section's version."""
+    async def _score(self, repo: str, *, judge: bool = True) -> None:
+        """Score ``repo`` with the ``slop_meter`` section as it reads it, recording that section's version.
+
+        From the rows and the mirror's files as kept: nothing is fetched and
+        nothing is read from the forge. ``judge`` asks the model about a few
+        outlier commits not judged yet first; a rescore for a change of the
+        settings does not, so it spends nothing: a new outlier stays unjudged,
+        and the score provisional, until the next run.
+        """
         settings = self._meter.repo(repo)
         version = config_version(settings)
+        self._tried[repo] = version
         inputs = await self._inputs(repo, settings)
-        await self._judge(repo, inputs)
+        if judge:
+            await self._judge(repo, inputs)
         results = await asyncio.to_thread(compute, inputs)
         now = self._clock()
         await self._store.store(repo, results, now, config_version=version)
@@ -564,8 +649,7 @@ async def _score(self, repo: str) -> None:
     async def _judge(self, repo: str, inputs: Inputs) -> None:
         """Ask the model about a few outlier commits not judged yet; what it answers is kept on ``inputs``."""
         settings = inputs.settings
-        weigh = weigher_for(inputs.commits, inputs.files, settings)
-        pending = [o for o in outliers(inputs.commits, weigh, inputs.judgments, settings) if o.slop is None]
+        pending = await asyncio.to_thread(unjudged, inputs)
         if not pending:
             return
         lookup = self._lookup if self._lookup is not None else (await self._read()).models
@@ -601,21 +685,57 @@ def wait_seconds(self) -> float:
             return 0.0
         return min(LOOK_SECONDS, max(0.0, (self._due - self._clock()).total_seconds()))
 
-    def _changed(self, read: MeterRead) -> list[str]:
-        """The repositories the last run read whose configuration version is another now."""
-        return [repo for repo, version in self._versions.items() if config_version(read.meter.repo(repo)) != version]
+    async def rescore_changed(self, read: MeterRead | None = None) -> list[str]:
+        """Rescore each repository in scope whose stored score was computed with another configuration version than
+        the one it reads now: an operator changed what its score is computed from. Answers the ones rescored.
+
+        Only those, from their rows and mirrors as kept, with no fetch, no
+        forge call and no judgment (:meth:`_score`), so a change made every few
+        minutes costs a rescore of what it touches and nothing more. One still
+        reading its history is left to its catch-up, and each version is tried
+        once per process.
+        """
+        if read is None:
+            read = await self._read()
+        registered = await self._repos()
+        names = read.enrollment.scope(SCOPE, registered.active)
+        if not names:
+            return []
+        stored = await self._store.versions()
+        changed: list[str] = []
+        for repo in names:
+            version = config_version(read.meter.repo(repo))
+            held = stored.get(repo)
+            if held is not None and held != version and self._tried.get(repo) != version:
+                changed.append(repo)
+        if not changed:
+            return []
+        logger.info("slop_meter_settings_changed", repos=changed, hint="rescoring them from what was read")
+        self._meter = read.meter
+        rescored: list[str] = []
+        for repo in changed:
+            self._tried[repo] = config_version(read.meter.repo(repo))
+            state = await self._store.state(repo)
+            if int(state.get("commits_read") or 0) < int(state.get("commits_total") or 0):
+                continue  # still reading its history: its catch-up scores it
+            try:
+                await self._score(repo, judge=False)
+                rescored.append(repo)
+            except Exception as exc:  # noqa: BLE001 - one repository's failure never stops the rest
+                await self._failed(repo, exc)
+        return rescored
 
-    async def scheduled(self) -> bool:
-        """What the schedule does each time it looks; True when it ran.
+    async def scheduled(self) -> str | None:
+        """What the schedule does each time it looks: ``"run"``, ``"rescore"`` or nothing (None).
 
         Reads the settings first, so turning the meter on or off and a new
-        interval apply at this look. It runs when the interval (or, while a
-        history is behind, ``catchup_seconds``) has passed since the last run
-        ended, at once when the meter was just turned on, and at once when the
-        ``slop_meter`` section reads another :func:`config_version` for a
-        repository the last run read: that rescores it. With the meter off a
-        run only removes what left the scope (:meth:`prune_only`), once an
-        interval.
+        interval apply at this look. It runs (:meth:`tick`, or with the meter
+        off :meth:`prune_only`, which only removes what left the scope) when
+        the interval, or while a history is behind ``catchup_seconds``, has
+        passed since the last run ended, and at once when the meter was just
+        turned on. Between runs, a repository whose stored score has another
+        configuration version than it reads now is rescored alone
+        (:meth:`rescore_changed`); the next run keeps its time.
         """
         read = await self._read()
         policy = read.meter.deployment()
@@ -629,25 +749,21 @@ async def scheduled(self) -> bool:
         last = self._last_pass
         if last is not None and not turned_on:
             next_run = last + timedelta(seconds=self._period(policy))
-            changed = self._changed(read) if policy.enabled and self._clock() < next_run else []
-            if self._clock() < next_run and not changed:
+            if self._clock() < next_run:
                 self._due = next_run
-                return False
-        else:
-            changed = []
-        if changed:
-            logger.info("slop_meter_settings_changed", repos=sorted(changed), hint="rescoring them now")
+                if policy.enabled and await self.rescore_changed(read):
+                    return "rescore"
+                return None
         try:
             if policy.enabled:
                 self._backlog = await self.tick(read)
             else:
                 self._backlog = False
-                self._versions = {}
                 await self.prune_only(read)
         finally:
             self._last_pass = self._clock()
             self._due = self._last_pass + timedelta(seconds=self._period(policy))
-        return True
+        return "run"
 
     def _period(self, policy: SlopMeterSettings) -> float:
         """Seconds from the end of one run to the next: ``catchup_seconds`` while a history is behind, else the
diff --git a/embry0/services/slop_meter/weights.py b/embry0/services/slop_meter/weights.py
index 52116b31..e02fea93 100644
--- a/embry0/services/slop_meter/weights.py
+++ b/embry0/services/slop_meter/weights.py
@@ -17,74 +17,80 @@
 import re
 import tomllib
 from collections.abc import Iterable, Mapping
-from dataclasses import dataclass
 from functools import lru_cache
 from statistics import quantiles
 from typing import Any
 
-from embry0.services.slop_meter.globs import compile_glob, marked
+from embry0.services.slop_meter.globs import GlobIndex, marked
 from embry0.settings.sections.slop_meter import SLOP_METER, SlopMeterSettings
 
-_LITERAL_SUFFIX = re.compile(r"\*[^*?/]+\Z")
+#: The most path weights one :class:`FileRules` keeps.
+_KEPT_MAX = 200_000
 
 
-@lru_cache(maxsize=4096)
-def _matcher(glob: str) -> tuple[str, Any]:
-    """How one glob is checked: a name's suffix for ``*`` and a literal (``*.py``, most globs), else its
-    expression (:func:`embry0.services.slop_meter.globs.compile_glob`)."""
-    lowered = glob.lower()
-    if _LITERAL_SUFFIX.match(lowered):
-        return lowered[1:], None
-    return lowered, compile_glob(lowered)
-
-
-def _hit(matcher: tuple[str, Any], path: str, name: str) -> bool:
-    text, pattern = matcher
-    if pattern is None:
-        return name.endswith(text)
-    return pattern.fullmatch(path if "/" in text else name) is not None
-
-
-@dataclass(frozen=True)
 class FileRules:
     """What a changed line of each file weighs, from the ``slop_meter`` section (:meth:`of`).
 
-    ``weights`` are ``(glob, weight)`` pairs in the order they are tried:
-    the longest glob first, so the first that matches is the one that wins,
-    and between globs of one length the first in alphabetical order.
+    The globs of ``weights`` and ``test_files`` are compiled and indexed once
+    (:class:`embry0.services.slop_meter.globs.GlobIndex`): where several
+    match a file, the most specific counts. Each path's weight is kept, so one
+    run weighs a path once however often it is asked. Build one per run: the
+    kept weights are its own.
     """
 
-    weights: tuple[tuple[str, float], ...]
-    excluded_dirs: frozenset[str]
-    test_dirs: frozenset[str]
-    test_files: tuple[str, ...]
-    test_marks: frozenset[str]
-    test_weight: float
+    def __init__(
+        self,
+        weights: Mapping[str, float],
+        *,
+        excluded_dirs: Iterable[str],
+        test_dirs: Iterable[str],
+        test_files: Iterable[str],
+        test_marks: Iterable[str],
+        test_weight: float,
+    ) -> None:
+        self._weights: GlobIndex[float] = GlobIndex((glob, float(weight)) for glob, weight in weights.items())
+        self._tests: GlobIndex[bool] = GlobIndex((glob, True) for glob in test_files)
+        self.excluded_dirs = frozenset(name.lower() for name in excluded_dirs)
+        self.test_dirs = frozenset(name.lower() for name in test_dirs)
+        self.test_marks = frozenset(mark.lower() for mark in test_marks)
+        self.test_weight = float(test_weight)
+        self._kept: dict[str, float] = {}
 
     @classmethod
     def of(cls, settings: SlopMeterSettings) -> FileRules:
-        ordered = sorted(settings.weights.items(), key=lambda item: (-len(item[0]), item[0]))
         return cls(
-            weights=tuple((glob.lower(), float(weight)) for glob, weight in ordered),
-            excluded_dirs=frozenset(name.lower() for name in settings.excluded_dirs),
-            test_dirs=frozenset(name.lower() for name in settings.test_dirs),
-            test_files=tuple(glob.lower() for glob in settings.test_files),
-            test_marks=frozenset(mark.lower() for mark in settings.test_marks),
-            test_weight=float(settings.test_weight),
+            settings.weights,
+            excluded_dirs=settings.excluded_dirs,
+            test_dirs=settings.test_dirs,
+            test_files=settings.test_files,
+            test_marks=settings.test_marks,
+            test_weight=settings.test_weight,
         )
 
+    @property
+    def evaluations(self) -> int:
+        """How many globs these rules have checked a path against so far."""
+        return self._weights.evaluations + self._tests.evaluations
+
     def weight(self, path: str) -> float:
         """A path's weight before ignore lists and outliers: its glob's, a share for tests, 0 when excluded."""
+        kept = self._kept.get(path)
+        if kept is None:
+            if len(self._kept) >= _KEPT_MAX:
+                self._kept.clear()  # rules kept for long (the defaults) never grow without bound
+            kept = self._kept[path] = self._weigh(path)
+        return kept
+
+    def _weigh(self, path: str) -> float:
         lowered = path.lower()
         parts = lowered.split("/")
-        name = parts[-1]
         if any(p in self.excluded_dirs for p in parts[:-1]):
             return 0.0
-        weight = next((w for glob, w in self.weights if _hit(_matcher(glob), lowered, name)), 0.0)
+        weight = self._weights.best(lowered) or 0.0
         if weight and (
             any(p in self.test_dirs for p in parts[:-1])
-            or marked(name, self.test_marks)
-            or any(_hit(_matcher(glob), lowered, name) for glob in self.test_files)
+            or marked(parts[-1], self.test_marks)
+            or self._tests.best(lowered) is not None
         ):
             weight *= self.test_weight
         return weight
diff --git a/embry0/settings/effective.py b/embry0/settings/effective.py
index 9400b344..f715fc5c 100644
--- a/embry0/settings/effective.py
+++ b/embry0/settings/effective.py
@@ -19,11 +19,14 @@
 A key merged entry by entry (``Section.merged_keys``, #166) also answers
 ``merged_by_entry`` true and ``entries``: each entry of its value with the
 document it comes from, ``default``, the deployment's (``document`` or
-``bootstrap``), ``organization`` or ``repository``.
+``bootstrap``), ``organization`` or ``repository``. So does a list each
+document adds to (``Section.added_keys``, #169): each item, as ``entry`` and
+``value``, with the most general document that names it.
 """
 
 from __future__ import annotations
 
+import json
 from collections.abc import Iterable, Mapping
 from dataclasses import dataclass
 from datetime import datetime
@@ -117,6 +120,29 @@ def _entries(
     return [{"entry": entry, "value": value[entry], "source": source_of.get(entry, "default")} for entry in value]
 
 
+def _items(
+    value: list[Any],
+    default: Any,
+    deployment: tuple[str, Mapping[str, Any], str],
+    layers: list[dict[str, Any]],
+) -> list[dict[str, Any]]:
+    """Each item of an added key's value with the document that first adds it: the most general that names it."""
+    source_of: dict[str, str] = {}
+    deployment_source, stored, key = deployment
+    found: list[tuple[Any, str]] = [(default, "default")]
+    if deployment_source != "default":
+        found.append((stored.get(key), deployment_source))
+    found.extend((layer["value"], layer["layer"]) for layer in layers[1:] if layer["set"])
+    for items, source in found:
+        if isinstance(items, list | tuple):
+            for item in items:
+                source_of.setdefault(json.dumps(item, sort_keys=True), source)
+    return [
+        {"entry": item, "value": item, "source": source_of.get(json.dumps(item, sort_keys=True), "default")}
+        for item in value
+    ]
+
+
 def effective_view(
     catalog: Catalog,
     snapshot: Snapshot,
@@ -249,6 +275,9 @@ def effective_view(
             if key in section.merged_keys and isinstance(value, Mapping):
                 entry_out["merged_by_entry"] = True
                 entry_out["entries"] = _entries(value, defaults.get(key), (deployment_source, stored, key), layers)
+            elif key in section.added_keys and isinstance(value, list):
+                entry_out["merged_by_entry"] = True
+                entry_out["entries"] = _items(value, defaults.get(key), (deployment_source, stored, key), layers)
             keys.append(entry_out)
         sections.append({"name": section.name, "summary": section.summary, "keys": keys})
     out: dict[str, Any] = {
diff --git a/embry0/settings/layers.py b/embry0/settings/layers.py
index b4ccfbd8..7b3378e5 100644
--- a/embry0/settings/layers.py
+++ b/embry0/settings/layers.py
@@ -6,8 +6,9 @@
 (``Section.settable``), and replaces the inherited value of such a key
 whole, except a key of ``Section.merged_keys``, a mapping it merges entry by
 entry over the inherited one (:func:`merged`), as the deployment's document
-merges it over the section's default (:func:`over_default`). Every other key
-it holds is ignored.
+merges it over the section's default (:func:`over_default`), and a key of
+``Section.added_keys``, a list it adds its items to the inherited one with.
+Every other key it holds is ignored.
 
 A section can check its fields against each other, so a value accepted when
 it was written can be refused later, together with what it inherits, once
@@ -99,10 +100,21 @@ def _reason(errors: Sequence[Mapping[str, Any]], key: str | None) -> str:
 
 def merged(section: Section[Any], inherited: Mapping[str, Any], values: Mapping[str, Any]) -> dict[str, Any]:
     """A document's ``values`` as they apply over ``inherited``: each key of ``section.merged_keys`` it sets, a
-    mapping, holds the section's default entries, then the inherited ones, under its own; every other key as the
-    document wrote it."""
+    mapping, holds the section's default entries, then the inherited ones, under its own; each key of
+    ``section.added_keys`` it sets, a list, holds the section's default items, then the inherited ones, then its
+    own, each once; every other key as the document wrote it."""
     out = dict(values)
     defaults: dict[str, Any] | None = None
+    for key in section.added_keys & set(values):
+        own = values[key]
+        if not isinstance(own, list | tuple):
+            continue
+        defaults = defaults if defaults is not None else section.defaults().model_dump(mode="json")
+        items: list[Any] = []
+        for layer in (defaults.get(key), inherited.get(key), own):
+            if isinstance(layer, list | tuple):
+                items.extend(item for item in layer if item not in items)
+        out[key] = items
     for key in section.merged_keys & set(values):
         own = values[key]
         if not isinstance(own, Mapping):
diff --git a/embry0/settings/reference.py b/embry0/settings/reference.py
index 0f4f1ca2..07e28b1d 100644
--- a/embry0/settings/reference.py
+++ b/embry0/settings/reference.py
@@ -118,7 +118,11 @@ def _section_table(section: Section[Any]) -> list[str]:
     for key in section.fields:
         prop = _resolve(props.get(key, {}), defs)
         layers = [
-            f"{name}, entry by entry" if key in section.merged_keys else name
+            f"{name}, entry by entry"
+            if key in section.merged_keys
+            else f"{name}, added to"
+            if key in section.added_keys
+            else name
             for name, keys in (("organization", section.org_keys), ("repository", section.repo_keys))
             if key in keys
         ]
diff --git a/embry0/settings/registry.py b/embry0/settings/registry.py
index f2491661..670ae508 100644
--- a/embry0/settings/registry.py
+++ b/embry0/settings/registry.py
@@ -227,7 +227,10 @@ class Section[M: SectionModel]:
     entry by entry over what is below it, the deployment's over the field's
     default and a layer over what it inherits (its entries replace the entries
     of the same name below, and every other entry stays), each one also in
-    ``org_keys`` or ``repo_keys``.
+    ``org_keys`` or ``repo_keys``. ``added_keys`` are list fields a document
+    adds to what is below it the same way: the deployment's items after the
+    field's default ones and a layer's after what it inherits, each item once,
+    so no layer takes an item out of the list below it.
     ``env`` maps a field to the ``Embry0Config`` attribute its value is
     imported from, once (``embry0.settings.bootstrap``): a string is the
     attribute, an :class:`EnvImport` adds a converter, the parts it drops, or a
@@ -241,11 +244,13 @@ class Section[M: SectionModel]:
     repo_keys: frozenset[str] = frozenset()
     env: Mapping[str, str | EnvImport] = field(default_factory=dict)
     merged_keys: frozenset[str] = frozenset()
+    added_keys: frozenset[str] = frozenset()
 
     def __post_init__(self) -> None:
         object.__setattr__(self, "org_keys", frozenset(self.org_keys))
         object.__setattr__(self, "repo_keys", frozenset(self.repo_keys))
         object.__setattr__(self, "merged_keys", frozenset(self.merged_keys))
+        object.__setattr__(self, "added_keys", frozenset(self.added_keys))
         object.__setattr__(self, "env", dict(self.env))
         problems = _section_problems(self)
         if problems:
@@ -367,6 +372,7 @@ def _section_problems(section: Section[Any]) -> list[str]:
         ("repo_keys", section.repo_keys),
         ("env", section.env),
         ("merged_keys", section.merged_keys),
+        ("added_keys", section.added_keys),
     ):
         unknown = sorted(set(keys) - names)
         if unknown:
@@ -376,6 +382,13 @@ def _section_problems(section: Section[Any]) -> list[str]:
             problems.append(f"merged_keys names {key!r}, which no layer may set")
         if typing.get_origin(model.model_fields[key].annotation) is not dict:
             problems.append(f"merged_keys names {key!r}, which is not a mapping")
+    for key in sorted(section.added_keys & names):
+        if key not in section.org_keys | section.repo_keys:
+            problems.append(f"added_keys names {key!r}, which no layer may set")
+        if typing.get_origin(model.model_fields[key].annotation) not in (tuple, list):
+            problems.append(f"added_keys names {key!r}, which is not a list")
+        if key in section.merged_keys:
+            problems.append(f"{key!r} is in both merged_keys and added_keys")
     if not problems:
         problems.extend(_default_problems(section))
     if not problems:
diff --git a/embry0/settings/sections/slop_meter.py b/embry0/settings/sections/slop_meter.py
index 280322b7..6fb71461 100644
--- a/embry0/settings/sections/slop_meter.py
+++ b/embry0/settings/sections/slop_meter.py
@@ -22,10 +22,12 @@
 ``api_calls_per_tick``, ``rate_reserve`` and ``judge_prompt``
 (:data:`NOT_SCORED`) is what a score is computed from. Each score row records
 :func:`config_version`, a digest of those keys as its repository read them;
-a change to one of them changes the digest, and the meter rescores every
-repository it reads that the change reaches within five minutes, not at its
-next daily run. ``judge_prompt`` applies to the outlier commits judged after
-it changes: a judgment is kept and never asked again.
+a change to one of them changes the digest. Every five minutes the meter
+compares each repository's stored digest with the one it reads now, and
+rescores the repositories whose digests differ from what was read, with no
+fetch and no forge call, without waiting for its next run. ``judge_prompt``
+applies to the outlier commits judged after it changes: a judgment is kept
+and never asked again.
 
 **Layers.** What counts as code, how fast a team attends to it, where the
 level bands fall, the judge's guidance and the owner's own bots are an
@@ -33,10 +35,13 @@
 repository's own, for its layout (``weights``, ``excluded_dirs``,
 ``test_dirs``, ``test_files``, ``test_marks``). ``weights`` is merged entry
 by entry, so a layer adds or changes the globs it names and keeps every
-other. ``api_calls_per_tick`` and ``rate_reserve`` bound the forge calls one
-tick makes with a credential, so an organization may set them for the
-credential it reads with. Whether the meter runs and how often are the
-deployment's alone.
+other. ``bots`` and ``ai_agents`` add to what a layer inherits, so a bot the
+deployment lists counts for every organization and no layer takes one out;
+``excluded_dirs`` and the ``test_*`` lists replace what they inherit, so a
+repository can take back a directory the default excludes. A credential's
+forge budget is the deployment's ``api_calls_per_tick`` and
+``rate_reserve``; an organization's own values only narrow its own share of
+it. Whether the meter runs and how often are the deployment's alone.
 
 **Before this section** the reading pace was ``SLOP_METER_INTERVAL_SECONDS``
 (``0`` turned the reading off), ``SLOP_METER_API_CALLS_PER_TICK`` and
@@ -114,8 +119,9 @@
 MIN_INTERVAL_HOURS: Final = 0.25
 #: The most entries ``weights`` holds.
 MAX_WEIGHTS: Final = 1000
-#: The most entries ``bots`` and ``ai_agents`` hold, as ``slop_meter_bots`` held on the organization row.
-MAX_IDENTITIES: Final = 100
+#: The most entries ``bots`` and ``ai_agents`` hold once every layer has added its own: twice what
+#: ``slop_meter_bots`` held on the organization row.
+MAX_IDENTITIES: Final = 200
 MAX_IDENTITY_LENGTH: Final = 200
 MAX_LEVEL_NAME_LENGTH: Final = 60
 MAX_JUDGE_PROMPT_LENGTH: Final = 4000
@@ -145,13 +151,19 @@ def interval_from_env(value: Any) -> float:
     return max(MIN_INTERVAL_HOURS, seconds / 3600)
 
 
-def _each(values: tuple[str, ...], check: Any, what: str) -> tuple[str, ...]:
-    """``values`` when ``check`` takes each and no two are the same without regard to case."""
+def _checked(values: tuple[str, ...], check: Any, what: str) -> tuple[str, ...]:
+    """``values`` when ``check`` takes each."""
     for position, value in enumerate(values, start=1):
         try:
             check(value)
         except ValueError as exc:
             raise ValueError(f"{what} {position}: {exc}") from None
+    return values
+
+
+def _each(values: tuple[str, ...], check: Any, what: str) -> tuple[str, ...]:
+    """``values`` when ``check`` takes each and no two are the same without regard to case."""
+    _checked(values, check, what)
     if len({value.lower() for value in values}) != len(values):
         raise ValueError(f"name each {what} once")
     return values
@@ -167,8 +179,12 @@ def _identity(text: str) -> str:
 
 
 def _agent(text: str) -> str:
-    if not text or any(char.isspace() for char in text):
-        raise ValueError("an AI agent is the start of its commit address, such as aider@, with no blanks")
+    local, at, domain = text.partition("@")
+    if not local or not at or "@" in domain or any(char.isspace() for char in text):
+        raise ValueError(
+            "an AI agent is its commit address up to and including the @, such as aider@, or a whole address, "
+            "with no blanks"
+        )
     refuse_unprintable(text, what="an AI agent's address")
     return text
 
@@ -200,8 +216,9 @@ class SlopMeterSettings(SectionModel):
         le=10_000,
         description=(
             "Forge API calls one run may make with one credential, shared round-robin by the repositories read "
-            "with it, to read comments, reviews and logins. Where repositories of organizations that set "
-            "different values are read with one credential, the smallest applies. Git fetches are not API calls."
+            "with it, to read comments, reviews and logins: the deployment's value is the credential's budget. "
+            "An organization's value only narrows its own repositories' share of it, never widens it, and never "
+            "lowers another organization's on the same credential. Git fetches are not API calls."
         ),
     )
     rate_reserve: int = Field(
@@ -210,8 +227,8 @@ class SlopMeterSettings(SectionModel):
         le=100_000,
         description=(
             "The rate limit a credential keeps for the jobs that use it: once its remaining calls "
-            "(X-RateLimit-Remaining) drop below this, the run makes no further call with it. Where organizations "
-            "that set different values share one credential, the largest applies."
+            "(X-RateLimit-Remaining) drop below this, the run makes no further call with it. An organization's "
+            "larger value stops only its own repositories' reads sooner; a smaller one changes nothing."
         ),
     )
     # ---- what a changed line weighs ----
@@ -222,10 +239,13 @@ class SlopMeterSettings(SectionModel):
             "What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so "
             "data, documents and binaries never count. A glob with no '/' matches a file's name in any directory "
             "(*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' "
-            "matches within one name, '?' one character, '**' any directories. Where several match, the longest "
-            "glob wins (*.min.js over *.js). Write globs in lowercase, quoted: matching ignores case, and YAML "
-            "reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and "
-            "keeps every other, so a glob set to 0 stops counting."
+            "matches within one name, '?' one character, '**' any directories. Where several match, the most "
+            "specific wins: a glob with a '/' over any without one; between two with one, more segments free of "
+            "wildcards, then more segments, then more literal characters; between two without, more literal "
+            "characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every "
+            "file under generated/, whatever its kind. Write globs in lowercase, quoted: matching ignores case, "
+            "and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it "
+            "names and keeps every other, so a glob set to 0 stops counting."
         ),
     )
     excluded_dirs: tuple[DirName, ...] = Field(
@@ -411,19 +431,22 @@ class SlopMeterSettings(SectionModel):
         default=(),
         max_length=MAX_IDENTITIES,
         description=(
-            "The owner's own bots, as commit names, addresses or forge logins matched whole without regard to "
-            "case: their commits add lines but no attention, and as a co-author they count as an AI agent does. "
-            "Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) "
-            "and embry0's own commit identities. Was the organization's slop_meter_bots."
+            "Bots, as commit names, addresses or forge logins matched whole without regard to case: their commits "
+            "add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every "
+            "deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit "
+            "identities. Each document adds to the list it inherits, so a bot the deployment lists counts for "
+            "every organization; no layer takes one out. At most 200 in all. Was the organization's "
+            "slop_meter_bots."
         ),
     )
     ai_agents: tuple[Identity, ...] = Field(
         default=(),
         max_length=MAX_IDENTITIES,
         description=(
-            "AI coding agents beyond the known ones, as the start of their commit address (aider@), matched "
-            "without regard to case: a commit one authors adds lines but no attention, and one it co-authors "
-            "counts ai_coauthor_share of its author's hours."
+            "AI coding agents beyond the known ones, each its commit address up to and including the @ (aider@, "
+            "any domain) or a whole address (agent@tools.example), matched without regard to case: a commit one "
+            "authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's "
+            "hours. Each document adds to the list it inherits, as bots. At most 200 in all."
         ),
     )
 
@@ -500,12 +523,12 @@ def _prompt(cls, value: str) -> str:
     @field_validator("bots")
     @classmethod
     def _bots(cls, value: tuple[str, ...]) -> tuple[str, ...]:
-        return _each(value, _identity, "bot")
+        return _checked(value, _identity, "bot")
 
     @field_validator("ai_agents")
     @classmethod
     def _ai_agents(cls, value: tuple[str, ...]) -> tuple[str, ...]:
-        return _each(value, _agent, "AI agent")
+        return _checked(value, _agent, "AI agent")
 
     @model_validator(mode="after")
     def _core_ramp(self) -> SlopMeterSettings:
@@ -517,9 +540,11 @@ def _core_ramp(self) -> SlopMeterSettings:
 def config_version(settings: SlopMeterSettings) -> str:
     """A digest of every key a score is computed from (all but :data:`NOT_SCORED`), as a repository reads them.
 
-    Stable across processes and releases for the same values: the keys and
-    the entries of ``weights`` are sorted, and every value is written as the
-    model dumps it to JSON. Each score row records it.
+    The same for the same keys and values in any process: the keys and the
+    entries of ``weights`` are sorted, and every value is written as the
+    model dumps it to JSON. A release that adds a key to what a score is
+    computed from changes every digest, so its first run rescores every
+    repository. Each score row records it.
     """
     values = {key: value for key, value in settings.model_dump(mode="json").items() if key not in NOT_SCORED}
     text = json.dumps(values, sort_keys=True, separators=(",", ":"), ensure_ascii=True)
@@ -547,6 +572,8 @@ def config_version(settings: SlopMeterSettings) -> str:
     org_keys=_ORG_KEYS,
     repo_keys=_REPO_KEYS,
     merged_keys=frozenset({"weights"}),
+    # A bot or an agent the deployment knows is one in every organization: each layer adds to the lists.
+    added_keys=frozenset({"bots", "ai_agents"}),
     env={
         "enabled": EnvImport(_INTERVAL_VARIABLE, enabled_from_env),
         "interval_hours": EnvImport(_INTERVAL_VARIABLE, interval_from_env),
diff --git a/embry0/storage/repositories/slop_meter.py b/embry0/storage/repositories/slop_meter.py
index 4ef4380a..f6481afa 100644
--- a/embry0/storage/repositories/slop_meter.py
+++ b/embry0/storage/repositories/slop_meter.py
@@ -258,6 +258,11 @@ async def store(
                 ],
             )
 
+    async def versions(self) -> dict[str, str]:
+        """Each scored repository's configuration version, as its repository score (area '') records it."""
+        rows = await self._db.fetch("SELECT repo, config_version FROM slop_meter_scores WHERE area = ''")
+        return {str(r["repo"]): str(r["config_version"]) for r in rows}
+
     async def scores(self, repo: str | None = None) -> list[dict[str, Any]]:
         rows = await self._db.fetch(
             "SELECT * FROM slop_meter_scores WHERE ($1::text IS NULL OR repo = $1) ORDER BY repo, area", repo
diff --git a/tests/unit/api/test_background_scope_wiring.py b/tests/unit/api/test_background_scope_wiring.py
index 52f767d4..e348fb9f 100644
--- a/tests/unit/api/test_background_scope_wiring.py
+++ b/tests/unit/api/test_background_scope_wiring.py
@@ -44,8 +44,9 @@ def test_the_meter_lists_registered_repositories_and_reads_its_enrollment_every_
         "the meter's candidates are the registered repositories, active or not (it reads the active ones and "
         f"keeps what it read of the inactive), never the world map's regions: got repos={passed.get('repos')!r}"
     )
-    assert passed.get("read") == "meter_reader(app.state.settings)", (
-        "the meter reads background.slop_meter and its judge's model from one snapshot a tick: "
+    assert passed.get("read") == "meter_reader(app.state.settings, config)", (
+        "the meter reads background.slop_meter, its judge's model and the slop_meter section from one snapshot a "
+        "tick, and the old variables of a key the import has not imported (#169): "
         f"got read={passed.get('read')!r}"
     )
     assert "models" not in passed, "no second reader of the settings documents: a tick could mix two versions"
diff --git a/tests/unit/api/test_slop_meter_settings_live.py b/tests/unit/api/test_slop_meter_settings_live.py
index 34df2450..fd6f478e 100644
--- a/tests/unit/api/test_slop_meter_settings_live.py
+++ b/tests/unit/api/test_slop_meter_settings_live.py
@@ -175,7 +175,8 @@ async def test_a_weight_changed_in_the_document_rescores_on_the_next_run_and_rec
     db = db_with_migrations
     clock = [NOW]
     loop = _meter(app, clock)
-    assert await loop.scheduled() is True, "the first look reads and scores the enrolled repository"
+    assert await loop.scheduled() == "run", "the first look reads and scores the enrolled repository"
+    fetched = len(loop._mirror.synced)  # noqa: SLF001 - the fake mirror records each fetch
     first_score, first_version = await _score(db)
     assert first_version == await _effective_version(app) != "", (
         "the score records the version of the settings acme/widgets reads"
@@ -184,7 +185,8 @@ async def test_a_weight_changed_in_the_document_rescores_on_the_next_run_and_rec
     resp = await _patch(app, {"weights": {"*.sql": 0.1}}, owner="acme")
     assert resp.status_code == 200, resp.text
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is True, "a weight changed: the next look rescores, without waiting for the day"
+    assert await loop.scheduled() == "rescore", "a weight changed: the next look rescores, without waiting for the day"
+    assert len(loop._mirror.synced) == fetched, "from what was read: nothing is fetched"  # noqa: SLF001
     second_score, second_version = await _score(db)
     assert second_version == await _effective_version(app) != first_version, (
         f"the rescored row records the new version: {first_version} → {second_version}"
@@ -198,15 +200,15 @@ async def test_a_weight_changed_in_the_document_rescores_on_the_next_run_and_rec
     undo = await _call(app, "POST", f"{URL}/revisions/{newest['id']}/undo")
     assert undo.status_code == 200, f"the change has history with undo: {undo.text}"
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is True, "undoing it is a change too"
+    assert await loop.scheduled() == "rescore", "undoing it is a change too"
     assert await _score(db) == (first_score, first_version), "and scores as before, recording the first version"
 
 
 async def test_a_write_names_every_refused_key_and_a_repository_may_set_only_its_layout(app: Any) -> None:
-    resp = await _patch(app, {"weights": {"*.PY": 1}, "level_bounds": [0.5, 0.4, 0.6, 0.8], "bots": ["x", "X"]})
+    resp = await _patch(app, {"weights": {"*.PY": 1}, "level_bounds": [0.5, 0.4, 0.6, 0.8], "ai_agents": ["dev"]})
     assert resp.status_code == 422, resp.text
     named = {tuple(problem["loc"])[-1] for problem in resp.json()["detail"]}
-    assert {"weights", "level_bounds", "bots"} <= named, f"422 names every refused key: {resp.json()['detail']}"
+    assert {"weights", "level_bounds", "ai_agents"} <= named, f"422 names every refused key: {resp.json()['detail']}"
     assert (await _patch(app, {"weights": {"generated/**": 0}}, repo=REPO)).status_code == 200
     refused = await _patch(app, {"lines_per_hour": 10}, repo=REPO)
     assert refused.status_code == 422 and "lines_per_hour" in refused.text, "a team's pace is its organization's"
@@ -230,12 +232,31 @@ async def test_a_write_names_every_refused_key_and_a_repository_may_set_only_its
 
 
 async def test_an_organization_s_bots_move_into_its_layer(app: Any, db_with_migrations: DatabasePool) -> None:
-    resp = await _call(app, "PATCH", "/api/v1/orgs/acme", json={"settings": {"slop_meter_bots": [" release-bot "]}})
-    assert resp.status_code == 200, resp.text
+    await _put(app, "slop_meter:\n  enabled: true\n  bots: [ci-runner]\n")
+    bots = {"slop_meter_bots": [" release-bot ", "Release-Bot", "tab\tbot"]}
+    resp = await _call(app, "PATCH", "/api/v1/orgs/acme", json={"settings": bots})
+    assert resp.status_code == 200, f"a list the route took before is taken, each bot once: {resp.text}"
     assert [note["moved_to"] for note in resp.json()["deprecated"]] == ["slop_meter.bots"], resp.json()
     layer = await _call(app, "GET", URL, params={"owner": "acme"})
-    assert layer.json()["data"]["slop_meter"]["bots"] == ["release-bot"], "written into acme's layer"
+    assert layer.json()["data"]["slop_meter"]["bots"] == ["release-bot"], (
+        "written into acme's layer once, the entry the section cannot hold left out"
+    )
     assert "slop_meter_bots" not in resp.json()["settings"], "and no longer shown as the organization's own"
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    snapshot = await app.state.settings.snapshot()
+    assert snapshot.scoped(SLOP_METER).repo(REPO).bots == ("ci-runner", "release-bot"), (
+        "acme's bots add to the deployment's: a bot the deployment lists counts for every organization"
+    )
+    effective = (await _call(app, "GET", f"{URL}/effective", params={"repo": REPO})).json()
+    [section] = [s for s in effective["sections"] if s["name"] == "slop_meter"]
+    listed = next(k for k in section["keys"] if k["key"] == "bots")
+    assert listed["merged_by_entry"] and {e["entry"]: e["source"] for e in listed["entries"]} == {
+        "ci-runner": "document",
+        "release-bot": "organization",
+    }, f"the values in effect name the document each bot comes from: {listed}"
+    posted = await _call(app, "POST", "/api/v1/orgs", json={"owner": "initech", "probe": False, "settings": bots})
+    assert posted.status_code == 201, f"registering an owner with them registers it and writes its layer: {posted.text}"
 
     # An owner whose row still lists bots its layer never imported (registered and written after the start's
     # copy) is read from its row, and copied into its layer by the budget policy's retry.
@@ -259,12 +280,36 @@ async def test_the_first_start_copies_each_organization_s_bots_into_its_layer(
     db = db_with_migrations
     await db.execute(
         "INSERT INTO organizations (owner, forge, settings) VALUES ('acme', 'github', $1::jsonb)",
-        {"slop_meter_bots": ["release-bot", "Release-Bot", " ", "ci@acme.example"]},
+        {"slop_meter_bots": ["release-bot", "Release-Bot", " ", "zero\u200bwidth", "ci@acme.example"]},
     )
     app = create_app(_config(db, tmp_path))
     async with lifespan(app):
         await _started(app)
         layer = await _call(app, "GET", URL, params={"owner": "acme"})
     assert layer.json()["data"].get("slop_meter", {}).get("bots") == ["release-bot", "ci@acme.example"], (
-        f"the start copies the owner's bots into its layer, each once: {layer.json()['data']}"
+        "the start copies the owner's bots into its layer, each once, leaving out the entry the section cannot "
+        f"hold rather than refusing the list: {layer.json()['data']}"
+    )
+
+
+async def test_a_moved_setting_the_section_refuses_is_refused_before_the_owner_is_registered(
+    app: Any, monkeypatch: pytest.MonkeyPatch
+) -> None:
+    """``POST /orgs`` checks each moved setting as its layer would take it before registering anything, so a
+    refusal never leaves an owner registered without the layer it asked for. Shown here with the cleaning of
+    ``slop_meter_bots`` turned off, since a cleaned list is one the section always takes."""
+    import dataclasses
+
+    from embry0.services import organizations as org_service
+
+    monkeypatch.setitem(
+        org_service.MOVED, "slop_meter_bots", dataclasses.replace(org_service.MOVED["slop_meter_bots"], write=None)
+    )
+    posted = await _call(
+        app,
+        "POST",
+        "/api/v1/orgs",
+        json={"owner": "umbrella", "probe": False, "settings": {"slop_meter_bots": ["a\tb"]}},
     )
+    assert posted.status_code == 422 and "slop_meter_bots" in posted.text, posted.text
+    assert await app.state.organizations_repo.get("umbrella") is None, "nothing was registered"
diff --git a/tests/unit/services/slop_meter/test_loop.py b/tests/unit/services/slop_meter/test_loop.py
index f6272834..b4fb2f77 100644
--- a/tests/unit/services/slop_meter/test_loop.py
+++ b/tests/unit/services/slop_meter/test_loop.py
@@ -60,7 +60,7 @@ def __init__(self) -> None:
         self.judged: dict[tuple[str, str], bool] = {}
         self.stored: dict[str, Any] = {}
         #: Each repository's configuration version, as its last scoring recorded it.
-        self.versions: dict[str, str] = {}
+        self.versions_of: dict[str, str] = {}
 
     async def state(self, repo: str) -> dict[str, Any]:
         return dict(self.states.get(repo, {"repo": repo, "commits_read": 0}))
@@ -105,7 +105,10 @@ async def judge(self, repo: str, sha: str, *, slop: bool, reason: str, model: st
 
     async def store(self, repo: str, results: dict[str, Any], computed_at: datetime, config_version: str = "") -> None:
         self.stored[repo] = results
-        self.versions[repo] = config_version
+        self.versions_of[repo] = config_version
+
+    async def versions(self) -> dict[str, str]:
+        return dict(self.versions_of)
 
 
 async def _no_bots() -> tuple[str, ...]:
diff --git a/tests/unit/services/slop_meter/test_loop_settings.py b/tests/unit/services/slop_meter/test_loop_settings.py
index 1c687213..80cab408 100644
--- a/tests/unit/services/slop_meter/test_loop_settings.py
+++ b/tests/unit/services/slop_meter/test_loop_settings.py
@@ -2,10 +2,12 @@
 
 On the fakes of test_loop.py: no git, no network, no database. Each score
 records the configuration version its repository read; a change to what a
-score is computed from rescores at the next look instead of at the next
-interval; ``enabled`` and ``interval_hours`` pace the schedule; each
-organization's forge budget applies to the credential it reads with; and the
-section's bots, AI agents and judge guidance reach the scoring.
+score is computed from rescores, at the next look, only the repositories it
+touches, from what was read, with no fetch and no forge call; ``enabled`` and
+``interval_hours`` pace the schedule; a credential's forge budget is the
+deployment's, an organization's values narrowing only its own share; and the
+section's bots, AI agents and judge guidance reach the scoring, the weighing
+off the event loop.
 """
 
 from __future__ import annotations
@@ -125,35 +127,72 @@ async def test_a_score_records_the_configuration_version_of_its_repository_s_set
     store = fakes.FakeStore()
     loop = _loop(Section({"weights": {"*.sql": 1.0}}), store, fakes.FakeMirror(records, order), [NOW])
     assert await loop.tick() is False
-    assert store.versions[REPO] == _version({"weights": {"*.sql": 1.0}}) != _version({}), (
-        f"the score records the version of the settings it was computed with: {store.versions}"
+    assert store.versions_of[REPO] == _version({"weights": {"*.sql": 1.0}}) != _version({}), (
+        f"the score records the version of the settings it was computed with: {store.versions_of}"
     )
 
 
-async def test_a_changed_weight_rescores_at_the_next_look_and_records_the_new_version() -> None:
+class Mirrors(fakes.FakeMirror):
+    """One fake history for every repository; ``synced`` names each fetch."""
+
+
+async def test_a_changed_weight_rescores_only_the_repository_it_touches_with_no_fetch_and_no_forge_call() -> None:
+    acme, globex = "acme/web", "globex/web"
     records, order = _sql_history()
-    store, clock = fakes.FakeStore(), [NOW]
+    forges = {name: fakes.FakeForge(repo=name) for name in (acme, globex)}
+    store, mirror, clock = fakes.FakeStore(), Mirrors(records, order), [NOW]
     section = Section()
-    loop = _loop(section, store, fakes.FakeMirror(records, order), clock)
-    assert await loop.scheduled() is True, "the first look runs at once"
-    before = store.stored[REPO][""]
-    assert store.versions[REPO] == _version({})
+    loop = _loop(section, store, mirror, clock, repos=(acme, globex), forges=forges)
+    assert await loop.scheduled() == "run", "the first look runs at once"
+    before = {repo: store.stored[repo][""] for repo in (acme, globex)}
+    first = dict(store.versions_of)
+    fetched, called = len(mirror.synced), {name: len(forge.calls) for name, forge in forges.items()}
+    assert fetched == 2 and all(called.values()), "the run fetched both and read both forges"
+
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is False, "nothing changed and the day has not passed: no run"
-    section.values = {"weights": {"*.sql": 0.0}}
+    assert await loop.scheduled() is None, "nothing changed and the day has not passed: nothing runs"
+    section.owners["acme"] = {"weights": {"*.sql": 0.0}}
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is True, "a weight changed: the next look rescores, not tomorrow's run"
-    after = store.stored[REPO][""]
-    assert store.versions[REPO] == _version({"weights": {"*.sql": 0.0}}), "and records the new version"
-    assert sum(w.cost for w in after.weeks) < sum(w.cost for w in before.weeks), (
-        "SQL weighing nothing lowers the attention cost the score is computed from"
+    assert await loop.scheduled() == "rescore", "acme's weight changed: the next look rescores"
+    assert len(mirror.synced) == fetched, "with no fetch"
+    assert {name: len(forge.calls) for name, forge in forges.items()} == called, "and no forge call, for either"
+    assert store.versions_of[acme] == _version({"weights": {"*.sql": 0.0}}) != first[acme], "acme records its new one"
+    assert store.versions_of[globex] == first[globex] and store.stored[globex][""] is before[globex], (
+        "globex, which the change does not touch, is not rescored"
+    )
+    assert sum(w.cost for w in store.stored[acme][""].weeks) < sum(w.cost for w in before[acme].weeks), (
+        "SQL weighing nothing lowers acme's attention cost"
     )
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is False, "once rescored, the next look waits for the interval again"
+    assert await loop.scheduled() is None, "once rescored, the next look does nothing"
     assert 0 < loop.wait_seconds() <= loop_mod.LOOK_SECONDS
+    clock[0] = NOW + timedelta(hours=24, minutes=1)
+    assert await loop.scheduled() == "run", "the full run keeps its interval from the last one"
+    assert len(mirror.synced) == fetched + 2
+
+
+async def test_a_repository_whose_rescore_fails_is_not_tried_again_every_look() -> None:
+    records, order = _sql_history()
+    store, mirror, clock = fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW]
+    section = Section()
+    loop = _loop(section, store, mirror, clock)
+    await loop.scheduled()
+    tries: list[str] = []
 
+    async def failing(repo: str, name: str) -> str | None:
+        tries.append(repo)
+        raise RuntimeError("the mirror cannot be read")
 
-async def test_a_key_no_score_is_computed_from_runs_nothing_early() -> None:
+    mirror.read = failing  # type: ignore[method-assign]
+    section.values = {"weights": {"*.sql": 0.0}}
+    for _ in range(3):
+        clock[0] += timedelta(minutes=5)
+        await loop.scheduled()
+    assert len(tries) == 1, f"one try per version, not one a look: {len(tries)} tries"
+    assert "the mirror cannot be read" in store.states[REPO]["error"], "and the failure is recorded"
+
+
+async def test_a_key_no_score_is_computed_from_rescores_nothing() -> None:
     records, order = _sql_history()
     store, clock = fakes.FakeStore(), [NOW]
     section = Section()
@@ -161,7 +200,7 @@ async def test_a_key_no_score_is_computed_from_runs_nothing_early() -> None:
     await loop.scheduled()
     section.values = {"api_calls_per_tick": 10, "judge_prompt": "Judge it."}
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is False, "the forge budget and the judge's guidance rescore nothing"
+    assert await loop.scheduled() is None, "the forge budget and the judge's guidance rescore nothing"
 
 
 async def test_off_reads_nothing_and_turned_on_it_reads_at_the_next_look() -> None:
@@ -169,13 +208,13 @@ async def test_off_reads_nothing_and_turned_on_it_reads_at_the_next_look() -> No
     store, mirror, clock = fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW]
     section = Section({"enabled": False})
     loop = _loop(section, store, mirror, clock)
-    assert await loop.scheduled() is True, "off, the first look still runs: it removes what left the scope"
+    assert await loop.scheduled() == "run", "off, the first look still runs: it removes what left the scope"
     assert mirror.synced == [] and store.stored == {}, "and reads and scores nothing"
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is False
+    assert await loop.scheduled() is None
     section.values = {}
     clock[0] += timedelta(minutes=5)
-    assert await loop.scheduled() is True, "turned on, the next look reads, not a day after the last removal"
+    assert await loop.scheduled() == "run", "turned on, the next look reads, not a day after the last removal"
     assert mirror.synced == [(REPO, "github")] and REPO in store.stored
 
 
@@ -185,38 +224,9 @@ async def test_the_interval_is_the_section_s() -> None:
     loop = _loop(Section({"interval_hours": 1}), store, fakes.FakeMirror(records, order), clock)
     await loop.scheduled()
     clock[0] += timedelta(minutes=59)
-    assert await loop.scheduled() is False and loop.wait_seconds() == pytest.approx(60), "due in a minute"
+    assert await loop.scheduled() is None and loop.wait_seconds() == pytest.approx(60), "due in a minute"
     clock[0] += timedelta(minutes=2)
-    assert await loop.scheduled() is True, "an hour after the last run ended"
-
-
-async def test_each_organization_s_forge_budget_applies_to_its_credential_and_a_shared_one_takes_the_strictest() -> (
-    None
-):
-    acme, globex = "acme/app", "globex/app"
-    records, order = fakes._history(2)
-    section = Section({}, acme={"api_calls_per_tick": 3, "rate_reserve": 0}, globex={"api_calls_per_tick": 12})
-
-    def forges() -> dict[str, Any]:
-        return {name: fakes.FakeForge(comment_pages=50, repo=name) for name in (acme, globex)}
-
-    apart = forges()
-    tokens = {acme: "token-acme", globex: "token-globex"}
-    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], repos=(acme, globex))
-    loop._client_for = _clients(apart)  # noqa: SLF001
-    loop._token_for = _tokens(tokens)  # noqa: SLF001
-    await loop.tick()
-    assert (len(apart[acme].calls), len(apart[globex].calls)) == (3, 12), (
-        "each organization's credential has the calls its organization allows: "
-        f"{len(apart[acme].calls)} and {len(apart[globex].calls)}"
-    )
-    shared = forges()
-    loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], repos=(acme, globex))
-    loop._client_for = _clients(shared)  # noqa: SLF001
-    await loop.tick()
-    assert len(shared[acme].calls) + len(shared[globex].calls) == 3, (
-        "read with one credential, the two share the fewer calls either organization allows"
-    )
+    assert await loop.scheduled() == "run", "an hour after the last run ended"
 
 
 def _clients(forges: Mapping[str, Any]) -> Any:
@@ -233,6 +243,48 @@ async def token_for(repo: str) -> tuple[str, str, str]:
     return token_for
 
 
+def _calls(forges: Mapping[str, Any]) -> dict[str, int]:
+    return {name: len(forge.calls) for name, forge in forges.items()}
+
+
+async def test_an_organization_s_budget_narrows_only_its_own_share_of_a_credential() -> None:
+    acme, globex = "acme/app", "globex/app"
+    records, order = fakes._history(2)
+
+    def forges(remaining: int = 4_000) -> dict[str, Any]:
+        return {name: fakes.FakeForge(comment_pages=50, repo=name, remaining=remaining) for name in (acme, globex)}
+
+    async def read_with(section: Section, found: dict[str, Any], tokens: Mapping[str, str] | None = None) -> None:
+        loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], repos=(acme, globex))
+        loop._client_for = _clients(found)  # noqa: SLF001
+        if tokens is not None:
+            loop._token_for = _tokens(tokens)  # noqa: SLF001
+        await loop.tick()
+
+    deployment = {"api_calls_per_tick": 20, "rate_reserve": 0}
+    shared = forges()
+    await read_with(Section(deployment, acme={"api_calls_per_tick": 0}), shared)
+    assert _calls(shared) == {acme: 0, globex: 20}, (
+        f"acme's 0 stops acme's reads alone; globex, on the same credential, reads the deployment's 20: {_calls(shared)}"
+    )
+    shared = forges()
+    await read_with(Section(deployment, acme={"rate_reserve": 100_000}), shared)
+    assert _calls(shared)[acme] == 1 and _calls(shared)[globex] == 19, (
+        f"acme's large reserve stops acme after the first answer names the limit; globex goes on: {_calls(shared)}"
+    )
+    shared = forges()
+    await read_with(Section(deployment, acme={"api_calls_per_tick": 5}, globex={"api_calls_per_tick": 500}), shared)
+    assert _calls(shared) == {acme: 5, globex: 15}, (
+        f"an organization's value narrows its share and never widens it past the credential's 20: {_calls(shared)}"
+    )
+    apart = forges()
+    tokens = {acme: "token-acme", globex: "token-globex"}
+    await read_with(Section(deployment, acme={"api_calls_per_tick": 3}), apart, tokens)
+    assert _calls(apart) == {acme: 3, globex: 20}, (
+        f"on two credentials, each has its own budget (#185): {_calls(apart)}"
+    )
+
+
 async def test_the_section_s_bots_and_ai_agents_are_bots_when_scored(monkeypatch: pytest.MonkeyPatch) -> None:
     def record(sha: str, hours: int, email: str, body: str = "Work") -> str:
         at = fakes.START + timedelta(hours=hours)
@@ -260,18 +312,66 @@ def spy(inputs: Any) -> Any:
     assert inputs.settings.bots == ("Release@Acme.example",), "the repository is scored with its owner's section"
 
 
-async def test_the_judge_hears_the_repository_s_guidance(monkeypatch: pytest.MonkeyPatch) -> None:
+async def test_the_judge_hears_the_repository_s_guidance_and_the_weighing_runs_off_the_event_loop(
+    monkeypatch: pytest.MonkeyPatch,
+) -> None:
     records, order = fakes._history(40)
     records["big"] = fakes._record("big", fakes.START + timedelta(days=200), [("src/drop.py", 9_000, 0)])
     order.append("big")
     heard: list[str] = []
+    threaded: list[str] = []
+    to_thread = loop_mod.asyncio.to_thread
 
     async def judge(repo: str, outlier: Any, ep: Any, client: Any, calls: Any, *, guidance: str) -> tuple[bool, str]:
         heard.append(guidance)
         return False, "a vendored parser"
 
+    async def spy(function: Any, *args: Any) -> Any:
+        threaded.append(function.__name__)
+        return await to_thread(function, *args)
+
     monkeypatch.setattr("embry0.services.slop_meter.judge.judge", judge)
+    monkeypatch.setattr(loop_mod.asyncio, "to_thread", spy)
     section = Section({}, acme={"judge_prompt": "Imports under third_party are never slop."})
     loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], model="custom/local")
     await loop.tick()
     assert heard == ["Imports under third_party are never slop."], f"the owner's guidance reached the judge: {heard}"
+    assert threaded == ["unjudged", "compute"], (
+        f"finding the outliers to judge weighs every path, so it runs in a thread, as the scoring does: {threaded}"
+    )
+
+
+async def test_until_the_import_succeeds_the_meter_reads_the_variables_it_read_before() -> None:
+    """A first start whose environment import failed leaves ``slop_meter.*`` out of the ledger: a deployment that
+    had the meter off (``SLOP_METER_INTERVAL_SECONDS=0``) keeps it off, as the budget's readers keep their caps."""
+    import os
+    from unittest.mock import patch
+
+    from embry0.config import Embry0Config
+    from embry0.settings.store import build_snapshot
+
+    _settings({})
+    with patch.dict(
+        os.environ, {"SLOP_METER_INTERVAL_SECONDS": "0", "SLOP_METER_API_CALLS_PER_TICK": "50"}, clear=True
+    ):
+        config = Embry0Config(_env_file=None)  # type: ignore[call-arg]
+
+    class Store:
+        def __init__(self, data: dict[str, Any], ledger: list[str]) -> None:
+            self.rows = [
+                {"scope": "deployment", "data": data, "generation": 1, "updated_at": None, "bootstrapped_keys": ledger},
+                {"scope": "organization:acme", "data": {"slop_meter": {"api_calls_per_tick": 7}}, "generation": 1},
+            ]
+
+        async def snapshot(self) -> Any:
+            return build_snapshot(CATALOG, self.rows, token=(), log=False)
+
+    pending = await loop_mod.meter_reader(Store({}, []), config)()
+    assert pending.meter.deployment().enabled is False, "not imported yet: the variable's 0 still turns it off"
+    assert pending.meter.repo("globex/web").api_calls_per_tick == 50, "and its budget is still the variable's"
+    assert pending.meter.repo(REPO).api_calls_per_tick == 7, "where an organization's layer sets one, it wins"
+    ledger = [f"slop_meter.{key}" for key in ("enabled", "interval_hours", "api_calls_per_tick", "rate_reserve")]
+    imported = await loop_mod.meter_reader(Store({}, ledger), config)()
+    assert imported.meter.deployment().enabled is True, "once imported, the document is read: here, nothing written"
+    written = await loop_mod.meter_reader(Store({"slop_meter": {"enabled": True}}, []), config)()
+    assert written.meter.deployment().enabled is True, "a key written into the document since wins"
diff --git a/tests/unit/services/slop_meter/test_prune.py b/tests/unit/services/slop_meter/test_prune.py
index bf393bff..40e38078 100644
--- a/tests/unit/services/slop_meter/test_prune.py
+++ b/tests/unit/services/slop_meter/test_prune.py
@@ -795,7 +795,7 @@ async def test_with_the_meter_off_it_still_removes_what_left_its_scope_at_its_fi
     exits.rows[("slop_meter", "acme/widgets")] = NOW - timedelta(days=8)
     store, mirror = Store(["acme/widgets", "other/kit"]), Mirror()
     loop = _meter(documents, store, mirror, ["acme/widgets", "other/kit"], exits=exits)
-    assert await loop.scheduled() is True
+    assert await loop.scheduled() == "run"
     assert store.forgotten == ["acme/widgets"] == mirror.removed, (
         "slop_meter.enabled: false stops the reading, not the removal: the first look removes what the meter "
         "kept of a repository whose week out of its scope has passed (reading other/kit would have failed: this "
diff --git a/tests/unit/services/slop_meter/test_scoring_settings.py b/tests/unit/services/slop_meter/test_scoring_settings.py
index 693e9900..af7a0a71 100644
--- a/tests/unit/services/slop_meter/test_scoring_settings.py
+++ b/tests/unit/services/slop_meter/test_scoring_settings.py
@@ -235,10 +235,47 @@ def _rules(values: dict[str, Any]) -> Any:
     return FileRules.of(settings)
 
 
-def test_the_longest_glob_wins_and_a_glob_with_a_slash_matches_from_the_root() -> None:
+def test_a_folder_glob_weighs_every_file_under_it_whatever_its_extension() -> None:
+    """A glob with a '/' is more specific than any glob without one, so it wins over the file's extension glob
+    however long that is: ranking by length let *.graphql beat gen/**."""
+    rules = _rules({"weights": {"gen/**": 0.0}})
+    for path in ("gen/a.py", "gen/api.proto", "gen/x.swift", "gen/schema.graphql", "gen/deep/er/x.min.js"):
+        assert type_weight(path, rules) == 0.0, f"{path} is under gen/"
+    assert type_weight("src/schema.graphql", rules) == 1.0 and type_weight("gene/a.py", rules) == 1.0
+
+
+def test_the_most_specific_glob_wins() -> None:
+    from embry0.services.slop_meter.globs import specificity
+
+    rules = _rules(
+        {
+            "weights": {
+                "src/**": 2.0,
+                "src/legacy/**": 0.2,
+                "src/legacy/keep/*.py": 3.0,
+                "**/vendored/*.go": 0.1,
+                "db/*": 0.7,
+                "db/schema.sql": 0.9,
+            }
+        }
+    )
+    assert type_weight("src/a.py", rules) == 2.0 and type_weight("src/README.md", rules) == 2.0, (
+        "src/** weighs every file under it"
+    )
+    assert type_weight("src/legacy/a.py", rules) == 0.2, "more segments free of wildcards: src/legacy/** over src/**"
+    assert type_weight("src/legacy/keep/a.py", rules) == 3.0, "three such segments over two"
+    assert type_weight("lib/vendored/x.go", rules) == 0.1, "a glob with a '/' over the extension's"
+    assert type_weight("db/schema.sql", rules) == 0.9 and type_weight("db/q.sql", rules) == 0.7
+    assert specificity("*.min.js") > specificity("*.js"), "between two without a '/', more literal characters"
+    assert specificity("a/b/c/*") > specificity("a/**/b.py") > specificity("**/b.py") > specificity("*.longername"), (
+        "segments free of wildcards first, then segments, then literal characters; any '/' over none"
+    )
+
+
+def test_the_most_specific_glob_wins_and_a_glob_with_a_slash_matches_from_the_root() -> None:
     rules = _rules({"weights": {"src/*.py": 2.0, "generated/**": 0.0, "*.sql": 1.0, "migrations/**/*.sql": 0.2}})
     assert type_weight("src/a.py", rules) == 2.0 and type_weight("lib/src/a.py", rules) == 1.0, (
-        "src/*.py is anchored at the root, and longer than *.py where both match"
+        "src/*.py is anchored at the root, and wins over *.py where both match"
     )
     assert type_weight("Generated/deep/x.py", rules) == 0.0, "generated/** reaches every file below it, any case"
     assert type_weight("migrations/v1/up.sql", rules) == 0.2 and type_weight("db/q.sql", rules) == 1.0
@@ -247,6 +284,24 @@ def test_the_longest_glob_wins_and_a_glob_with_a_slash_matches_from_the_root() -
     assert type_weight("README.md", rules) == 0.0, "a file no glob matches weighs nothing"
 
 
+def test_a_path_is_checked_against_the_few_globs_that_could_match_it() -> None:
+    """20,000 paths under 200 directories, against the default globs and 900 globs of other directories: each
+    path is checked against a handful, not against every glob, and each path once however often it is asked."""
+    rng = random.Random(3)
+    extensions = ("py", "ts", "js", "go", "rs", "java", "md", "json", "tsx", "css", "proto", "swift")
+    paths = [f"d{rng.randrange(200)}/s{rng.randrange(50)}/f{i}.{rng.choice(extensions)}" for i in range(20_000)]
+    rules = _rules({"weights": {f"x{i}/legacy/**": 0.0 for i in range(900)}})
+    weigh = Weigher(rules=rules)
+    for path in paths + paths:
+        weigh(path)
+    for path in paths:
+        type_weight(path, rules)
+    assert rules.evaluations < 5 * len(paths), (
+        f"{rules.evaluations} glob checks for {len(paths)} paths: a path is checked against every glob, or more "
+        "than once"
+    )
+
+
 def test_what_a_test_is_and_what_it_weighs() -> None:
     assert type_weight("pkg/a_test.go") == 0.5
     full = _rules({"test_weight": 1.0})
diff --git a/tests/unit/settings/test_layers.py b/tests/unit/settings/test_layers.py
index d7f6b39d..49181a6f 100644
--- a/tests/unit/settings/test_layers.py
+++ b/tests/unit/settings/test_layers.py
@@ -222,3 +222,32 @@ class Mapped(SectionModel):
 
     with pytest.raises(SectionError, match="merged_keys names 'limits', which no layer may set"):
         Section(name="mapped", model=Mapped, summary="A test section.", merged_keys=frozenset({"limits"}))
+
+
+def test_an_added_key_holds_what_every_document_below_lists_and_its_own() -> None:
+    """``added_keys`` (#169): a list a layer adds its items to, after the inherited ones and the default's, each
+    once; no layer takes an item out of the list below it. Any other key still replaces whole."""
+    from embry0.settings.registry import Section
+
+    assert "added_keys" in Section.__dataclass_fields__, "a section names the list keys a layer adds to"
+    section = _mapped_section(added_keys=frozenset({"names"}))
+    over_default = resolve(section, {}, [("organization:acme", {"names": ["z", "x"]})])
+    assert over_default.model.model_dump(mode="json")["names"] == ["x", "y", "z"], "the default's, then its own"
+    over_stored = resolve(section, {"names": ["x", "y", "w"]}, [("organization:acme", {"names": ["z"]})])
+    assert over_stored.model.model_dump(mode="json")["names"] == ["x", "y", "w", "z"], "over the deployment's"
+    plain = resolve(_mapped_section(), {}, [("organization:acme", {"names": ["z"]})])
+    assert plain.model.model_dump(mode="json")["names"] == ["z"], "without added_keys a layer replaces whole"
+
+
+@pytest.mark.parametrize(
+    ("added", "problem"),
+    [
+        ({"limits"}, "added_keys names 'limits', which is not a list"),
+        ({"nothing"}, "added_keys names no field of the model: ['nothing']"),
+    ],
+)
+def test_only_a_list_a_layer_may_set_can_be_added_to(added: set[str], problem: str) -> None:
+    from embry0.settings.registry import SectionError
+
+    with pytest.raises(SectionError, match=re.escape(problem)):
+        _mapped_section(added_keys=frozenset(added))
diff --git a/tests/unit/settings/test_slop_meter_section.py b/tests/unit/settings/test_slop_meter_section.py
index abade3db..eec27e86 100644
--- a/tests/unit/settings/test_slop_meter_section.py
+++ b/tests/unit/settings/test_slop_meter_section.py
@@ -150,7 +150,7 @@ def test_every_refused_key_is_named_in_one_answer() -> None:
             "test_weight": 1.5,
             "level_bounds": [0.2, 0.2, 0.6, 0.8],
             "level_names": ["One", "Two", "Three", "Four"],
-            "bots": ["release-bot", "Release-Bot"],
+            "bots": ["release-bot", "line\nbreak"],
             "ai_agents": ["aider @"],
             "judge_prompt": "  \n ",
             "interval_hours": 0.1,
@@ -172,7 +172,7 @@ def test_every_refused_key_is_named_in_one_answer() -> None:
         "lines_per_hour",
     }, f"one answer names every refused key: {problems}"
     assert "lowercase" in problems["weights"] and "once" in problems["excluded_dirs"]
-    assert "above the one before" in problems["level_bounds"] and "once" in problems["bots"]
+    assert "above the one before" in problems["level_bounds"] and "one line" in problems["bots"]
 
 
 @pytest.mark.parametrize(
@@ -216,6 +216,46 @@ def test_an_organization_says_what_counts_and_a_repository_says_its_layout() ->
     assert section.merged_keys == {"weights"}, "weights merge entry by entry"
 
 
+def test_an_ai_agent_is_an_address_or_the_start_of_one_up_to_its_at() -> None:
+    for refused in (["dev"], ["a"], ["@tools.example"], ["a@b@c"], ["aider @"]):
+        assert "ai_agents" in _problems({"ai_agents": refused}), f"{refused} would name people's addresses too"
+    assert _problems({"ai_agents": ["aider@", "agent@tools.example"]}) == {}
+
+
+def test_bots_and_ai_agents_add_to_what_each_layer_inherits() -> None:
+    section = _section()
+    assert section.added_keys == {"bots", "ai_agents"}, "no layer takes out a bot the layer below lists"
+    snapshot = _snapshot(
+        {
+            "deployment": {"bots": ["ci-runner"], "ai_agents": ["helper@"]},
+            "organization:acme": {"bots": ["release-bot", "ci-runner"]},
+        }
+    )
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    widgets = snapshot.scoped(SLOP_METER).repo(WIDGETS)
+    assert widgets.bots == ("ci-runner", "release-bot"), "the deployment's bot counts in acme too, each once"
+    assert widgets.ai_agents == ("helper@",)
+    assert snapshot.scoped(SLOP_METER).repo(GADGETS).bots == ("ci-runner",), "and in every other organization"
+
+
+def test_a_text_of_several_lines_is_a_literal_block_in_the_settings_document_only() -> None:
+    """The settings document writes the judge's guidance as it reads; a progression pack, which keeps its own
+    writer and compares stored texts, writes exactly what it wrote before."""
+    import yaml
+
+    from embry0.services import progression_pack_store
+    from embry0.settings.document import dump_yaml
+
+    _section()
+    text = {"judge_prompt": "One line.\nAnother line."}
+    assert dump_yaml(text) == "judge_prompt: |-\n  One line.\n  Another line.\n"
+    assert yaml.safe_load(dump_yaml(text)) == text
+    assert progression_pack_store.dump_yaml(text) == yaml.safe_dump(
+        text, sort_keys=False, allow_unicode=True, default_flow_style=False, width=100
+    ), "a pack's YAML is unchanged, so no pack gets a new version"
+
+
 def test_weights_merge_entry_by_entry_through_every_layer() -> None:
     snapshot = _snapshot(
         {

From 70f58720d46fc9200bcf3acedb57051ef6ec243f Mon Sep 17 00:00:00 2001
From: Tomas McMonigal <74835766+sudoTomas@users.noreply.github.com>
Date: Fri, 6 Nov 2026 15:22:10 +0000
Subject: [PATCH 3/4] feat(slop): the Slop-O-Meter's scoring as a settings
 section

The meter kept all of its policy in code: the file weights and which
directories are vendored or tests, the pace and cap constants, the
small-repository rule, the level bounds and names and the judge's
prompt. An organization could not say what counts as code, how fast
its team works or where its levels fall, and changing a constant
silently rescored every repository. Its reading pace was three
variables, and an owner's own bots sat on its organization row.

Add a `slop_meter` section to the settings document. Every constant is
a key whose default is the value the code held, so nothing written
scores bit for bit as before: a fixture history reproduces the pinned
pre-change numbers, and 86,000 paths weigh what the old rules gave
them. An organization's layer may set every key but `enabled` and
`interval_hours`; a repository's what counts as code in its layout.
`weights` maps a glob to a weight, merged glob by glob through every
layer. Weigh paths by specificity: a folder glob beats any extension
glob, then more literal segments, fewer `**` and wildcard segments,
more segments, more literal characters. Globs are indexed by name,
extension, literal directory or segment and three-character runs; at
most 16 per list may be checked against every path. Each path is
weighed once a run, and the history, outliers and scores are built in
a thread.

Each score row records `config_version` (migration 144), a digest of
the keys its repository's score is computed from. The loop looks at
the section every five minutes: a settings change rescores only the
repositories it touches, from the rows and mirrors already read, with
no fetch, forge call or judgment, and the full run keeps its interval.
`enabled` and `interval_hours` apply within the look. A credential's
forge budget is the deployment's; an organization's values only narrow
its own share, and a repository stopped by that share is scored with
what it read instead of keeping the meter on catch-up. `bots` and
`ai_agents` add to what each layer inherits (a new `added_keys` for
list fields, each item once without regard to case), and an AI agent
is an address or the part of one up to its `@`. A write counts merged
and added keys with what they inherit; a read past the cap keeps the
layer's own entries and the inherited ones that fit.

SLOP_METER_INTERVAL_SECONDS (0 is `enabled: false`),
SLOP_METER_API_CALLS_PER_TICK and SLOP_METER_RATE_RESERVE are imported
once and read as before until the import succeeds. The organization
setting `slop_meter_bots` moves into its layer as `bots`, cleaned
(each bot once, unholdable entries left out) at the first start and on
PATCH or POST /orgs, which still take it until 0.2.0. The process
limits stay variables. The unread LEAN_LEVEL constant is deleted:
triage's lean belongs to the routing section a later pull request
adds. Multi-line texts in the settings YAML are written as literal
blocks; progression packs keep their own writer.

Refs #169
---
 docs/configuration.md                         |   8 +-
 docs/examples/settings.yaml                   |  21 +-
 docs/slop-meter.md                            |  26 ++-
 embry0/services/slop_meter/globs.py           | 204 +++++++++++++-----
 embry0/services/slop_meter/loop.py            |  44 +++-
 embry0/settings/document.py                   |  37 +++-
 embry0/settings/layers.py                     | 112 ++++++++--
 embry0/settings/registry.py                   |   7 +-
 embry0/settings/sections/slop_meter.py        |  51 ++++-
 .../services/slop_meter/test_loop_settings.py |  35 ++-
 .../slop_meter/test_scoring_settings.py       |  56 ++++-
 .../unit/settings/test_slop_meter_section.py  |  62 ++++++
 12 files changed, 551 insertions(+), 112 deletions(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 79286a40..386e7873 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -307,7 +307,7 @@ asks:
 - **In the dashboard**, Settings → Policy holds the same three things, for one document at a time. The **Layer** picker above them chooses the deployment's document, an organization's layer or a repository's: it offers every organization and repository the lists show and every stored layer, each marked with how many keys its layer sets, and keeps the choice in the URL (`/settings?tab=policy&owner=acme`, `&repo=acme/widgets`), so a layer can be linked to; an organization's Settings tab and a repository's page link to their own. Picking one with no layer opens an empty one that its first save creates, and picking another while an edit is unsaved asks first. The document is a YAML text box: **Preview** runs the dry run and lists each key the text would change, before and after, with the text diff; **Save** then stores exactly the previewed text, with an optional reason. Both name the generation the edit started from (0 for a layer nobody wrote), so if someone else saved in between they are refused, the new version is read in and your text stays in the box to preview again. A layer lists above its text the keys it may set, per section. A refused document lists every problem next to the text, each with its key, and marks a key the layer may not set. When a save, its preview or an undo makes values of the layers under the document read as inherited (`layers_refused`), the tab lists them, each linked to its layer. Below it, **Values in effect** shows every key of every section with its value, its default and where it came from, and warns when a stored value is refused, an imported variable is still set, or the document holds a section or key this release does not know; for a layer, as that organization or repository reads it: the layer each value comes from, what the layer's own value overrides ("Overrides "09-18" from the deployment"), what it inherits and from whom, and, dimmed, the keys it may not set. **History** lists the document's revisions, opens each one to show what it changed, and offers Undo on the newest. Anyone signed in can read the tab, with the people behind changes shown as the audit log shows them (someone else's name only to an admin); only an admin can preview, save or undo, and an API key with a repository allowlist only on a repository's layer the list covers. A document [kept in a file](#from-a-file-the-command-line-and-mcp) is shown read-only, to an admin too.
 - **From the environment.** When a release moves a feature's policy into a section, the first start of that release imports each of its variables you set, when the value differs from the default, once per key (source `bootstrap`); a key a later release adds to the section is imported at that release's first start. A variable left at its default is not imported, so a default the section changes reaches every deployment that never set it; where a section turns a default the other way on purpose, it declares the value a deployment that relied on the old meaning keeps, and how to tell one from its records (for `leads.enabled`: a registered repository, a job or a lead a finder stored). Only records older than the moment the release first asked about the key count: the import records that moment once in the document's ledger (`leads.enabled@<time>`, the database's clock when the process began, before the migrations), so a repository a new deployment registers while it waits, or between two starts, is never taken for its past. While the variable is not set, such a deployment gets that value written into the document under a comment saying why (`settings_default_kept`, once); a new one does not, and a value an operator has written stands. If that check fails (the database busy at the start), its key reads its default, `settings_bootstrap_check_failed` is logged at error level, and the check is asked again in the same run, after a minute and then at doubling intervals up to fifteen minutes, until it answers (`settings_bootstrap_check_settled`); a restart in between asks at its start, about the same moment. An import that fails outright is tried again in the same run the same way. A part of a variable the section drops, such as an unknown finder name in `LEADS_FINDERS`, is named in a `settings_env_value_dropped` warning. A value the section refuses is skipped with a `settings_bootstrap_value_refused` warning: set it in the document instead. A value refused only together with the section's other stored values is held (`settings_bootstrap_value_held`) and tried again at the next start. After that the variable is ignored: startup logs `settings_env_ignored` and `embry0 config` says the document governs it. The variable is removed one release later. The reference below names the variable each key was imported from.
 - **After a rollback.** A section or a key that a newer release wrote and this one does not know is kept as long as it is sent back exactly as stored (as the stored text has it, or as GET's `data` does), and is listed in `unknown_sections` or `unknown_keys`.
-- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). And `slop_meter.bots` and `slop_meter.ai_agents` are lists each document adds to: a layer's items join those it inherits, and no layer takes one out (the reference marks them *added to*; `entries` names the document each item comes from). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
+- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). And `slop_meter.bots` and `slop_meter.ai_agents` are lists each document adds to: a layer's items join those it inherits, each once without regard to case, and no layer takes one out (the reference marks them *added to*; `entries` names the document each item comes from). A write of a key merged or added to is counted with what it inherits: one that would hold more entries than the key may is a 422 naming the count. A layer read when a document below has grown past that keeps every entry of its own and the inherited ones that fit, in their order (`settings_layer_entries_left_out`). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
 - **Moved so far**, one section per bullet, in name order:
   - The asks policy (`asks`, from `ASKS_ENABLED` and the `ASK_*` variables): the ask loop reads it every tick and `GET /api/v1/asks/due` on every request, so turning asks on or changing their hours needs no restart. It is read per organization: an ask follows the layer of the organization its decision's repository belongs to for `hours`, `weekdays`, `timezone`, `remind_hours`, `expire_days` and `max_open_per_person`, and the deployment's document for the rest, so a change to an organization's layer applies to its asks on the next tick. An ask about a decision with no repository follows the deployment's document. `max_open_per_person` counts per person within an organization: someone asked about two organizations' decisions may hold each one's number, and the asks about decisions with no repository count apart. `enabled`, `lease_minutes` and `tick_seconds` are the deployment's alone.
   - Which repositories the background features read (`background`, from `SCOUT_REPOS`, `SCOUT_EXCLUDE`, `SLOP_METER_REPOS` and `SLOP_METER_EXCLUDE`, and what the scout and the Slop-O-Meter read before, into the repositories' layers): one switch per feature, `leads`, `scout` and `slop_meter`, which an organization's layer and a repository's layer may each set. A repository is read when it is registered, active and its switch resolves to true; nothing else enrolls it, not a job run on it. The scout and the meter are off until enrolled, and leads read every repository someone answers for unless a layer takes it out. Each loop reads it every tick, so opting a repository out stops it on the next one, and the meter removes what it kept of it `background.prune_after_days` (a week) later unless it comes back first ([which repositories](#which-repositories-background-features-read)).
@@ -552,7 +552,7 @@ How the Slop-O-Meter weighs a changed line and a person's attention, where its l
 | `interval_hours` | number | `24.0` | ≥ 0.25, ≤ 8760 |  | `SLOP_METER_INTERVAL_SECONDS` | Hours between two runs over every enrolled repository: fetch, read the next part of its history and events, and rescore it once caught up. While a history is still being read the meter comes back sooner (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At least a quarter hour. Was SLOP_METER_INTERVAL_SECONDS. The deployment's alone. |
 | `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins: the deployment's value is the credential's budget. An organization's value only narrows its own repositories' share of it, never widens it, and never lowers another organization's on the same credential. Git fetches are not API calls. |
 | `rate_reserve` | whole number | `2000` | ≥ 0, ≤ 100000 | organization | `SLOP_METER_RATE_RESERVE` | The rate limit a credential keeps for the jobs that use it: once its remaining calls (X-RateLimit-Remaining) drop below this, the run makes no further call with it. An organization's larger value stops only its own repositories' reads sooner; a smaller one changes nothing. |
-| `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the most specific wins: a glob with a '/' over any without one; between two with one, more segments free of wildcards, then more segments, then more literal characters; between two without, more literal characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every file under generated/, whatever its kind. Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting. |
+| `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the most specific wins: a glob with a '/' over any without one; between two with one, more segments free of wildcards, then fewer ** segments, then fewer other segments with a wildcard, then more segments, then more literal characters; between two without, more literal characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every file under generated/, whatever its kind, and src/main.py wins over src/**/main.py. At most 16 globs that name no literal directory, no extension and no three literal characters in a row (*/*, *x*). Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting; at most 1000 globs in all, counted with the defaults and what a write inherits. |
 | `excluded_dirs` | list of text | `["vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files weigh nothing, each one name matched at any depth: vendored and third-party code. A list replaces the one it inherits whole; [] excludes none. |
 | `test_dirs` | list of text | `["__tests__", "tests", "test", "spec", "specs", "examples", "example", "demos", "demo", "samples", "sample", "fixtures", "testdata"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files are tests or examples, each one name matched at any depth: their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
 | `test_files` | list of text | `["*_test.go", "*_test.py", "*_test.rb", "*_test.ex", "*_test.exs", "*_spec.rb", "test_?*.py"]` | at most 200 entries, each at most 200 characters | organization, repository |  | Globs of test and example files, in the grammar of weights (*_test.go, test_?*.py): their lines weigh test_weight of what weights says. A list replaces the one it inherits whole. |
@@ -575,8 +575,8 @@ How the Slop-O-Meter weighs a changed line and a person's attention, where its l
 | `judge_prompt` | text | `"You judge one large commit of a software repository: did it add bulk code no\nperson wrote or reviewed line by line (slop, such as a large AI-generated\nchange), or is its size explained by something else (not slop: the project's\ninitial import, a code drop moved in from elsewhere, a restructuring that moved\nfiles, a vendored or generated library, a data or fixture dump)?\nJudge from what the message and the files say. When it is unclear, answer\nslop: false only if the files themselves look moved, vendored or generated."` | at least 1 characters, at most 4000 characters | organization |  | What the model judging an outlier commit is told slop is and is not. The answer's form (JSON with slop and a reason) is added after it. Applies to commits judged after it changes: a judgment is kept and never asked again, so a change rescores nothing. |
 | `level_bounds` | list of number | `[0.2, 0.4, 0.6, 0.8]` | at least 4 entries, at most 4 entries | organization |  | Where the five levels part: a score below the first bound is level 1, below the second level 2, and so on; at or above the last, level 5. Four bounds, each above the one before, from 0 to 1. |
 | `level_names` | list of text | `["Buttered Noodles", "Spaghetti Bolognese", "Lasagna", "Sloppy Joe", "Just The Slop"]` | at least 5 entries, at most 5 entries, each at most 60 characters | organization |  | The five levels' names, level 1 (the least slop) first. Each one line, each named once. |
-| `bots` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | Bots, as commit names, addresses or forge logins matched whole without regard to case: their commits add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit identities. Each document adds to the list it inherits, so a bot the deployment lists counts for every organization; no layer takes one out. At most 200 in all. Was the organization's slop_meter_bots. |
-| `ai_agents` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | AI coding agents beyond the known ones, each its commit address up to and including the @ (aider@, any domain) or a whole address (agent@tools.example), matched without regard to case: a commit one authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's hours. Each document adds to the list it inherits, as bots. At most 200 in all. |
+| `bots` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | Bots, as commit names, addresses or forge logins matched whole without regard to case: their commits add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit identities. Each document adds to the list it inherits, so a bot the deployment lists counts for every organization; no layer takes one out, and a bot spelled otherwise is the same one. At most 200 in all, counted with what a write inherits. Was the organization's slop_meter_bots. |
+| `ai_agents` | list of text | `[]` | at most 200 entries, each at most 200 characters | organization, added to |  | AI coding agents beyond the known ones, each its commit address up to and including the @ (aider@, any domain) or a whole address (agent@tools.example), matched without regard to case: a commit one authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's hours. Each document adds to the list it inherits, as bots. At most 200 in all, counted with what a write inherits. |
 
 #### `ui`
 
diff --git a/docs/examples/settings.yaml b/docs/examples/settings.yaml
index 20e3fd4f..d1a95008 100644
--- a/docs/examples/settings.yaml
+++ b/docs/examples/settings.yaml
@@ -436,13 +436,17 @@ slop_meter:
   # '*' matches within one name, '?' one character, '**' any directories.
   # Where several match, the most specific wins: a glob with a '/' over any
   # without one; between two with one, more segments free of wildcards, then
-  # more segments, then more literal characters; between two without, more
-  # literal characters (*.min.js over *.js); then the first in alphabetical
-  # order. So generated/** weighs every file under generated/, whatever its
-  # kind. Write globs in lowercase, quoted: matching ignores case, and YAML
-  # reads a bare * as an alias. Merged entry by entry: a document adds or
+  # fewer ** segments, then fewer other segments with a wildcard, then more
+  # segments, then more literal characters; between two without, more literal
+  # characters (*.min.js over *.js); then the first in alphabetical order. So
+  # generated/** weighs every file under generated/, whatever its kind, and
+  # src/main.py wins over src/**/main.py. At most 16 globs that name no
+  # literal directory, no extension and no three literal characters in a row
+  # (*/*, *x*). Write globs in lowercase, quoted: matching ignores case, and
+  # YAML reads a bare * as an alias. Merged entry by entry: a document adds or
   # changes the globs it names and keeps every other, so a glob set to 0 stops
-  # counting.
+  # counting; at most 1000 globs in all, counted with the defaults and what a
+  # write inherits.
   # weights:
   #   '*.py': 1.0
   #   '*.pyi': 1.0
@@ -683,7 +687,8 @@ slop_meter:
   # knows ([bot] accounts, noreply@ addresses, known coding agents) and
   # embry0's own commit identities. Each document adds to the list it
   # inherits, so a bot the deployment lists counts for every organization; no
-  # layer takes one out. At most 200 in all. Was the organization's
+  # layer takes one out, and a bot spelled otherwise is the same one. At most
+  # 200 in all, counted with what a write inherits. Was the organization's
   # slop_meter_bots.
   # bots: []
 
@@ -692,7 +697,7 @@ slop_meter:
   # (agent@tools.example), matched without regard to case: a commit one
   # authors adds lines but no attention, and one it co-authors counts
   # ai_coauthor_share of its author's hours. Each document adds to the list it
-  # inherits, as bots. At most 200 in all.
+  # inherits, as bots. At most 200 in all, counted with what a write inherits.
   # ai_agents: []
 
 # What the dashboard shows: the game layer, and the page it opens on.
diff --git a/docs/slop-meter.md b/docs/slop-meter.md
index 3573c2d1..08d1f535 100644
--- a/docs/slop-meter.md
+++ b/docs/slop-meter.md
@@ -74,19 +74,37 @@ slop_meter:
 **Globs.** A glob with no `/` matches a file's name in any directory (`*.py`); one with a `/` matches its path from the repository's root (`db/migrations/*.sql`, `generated/**`). `*` matches within one name, `?` one character, `**` any number of directories. Matching ignores case, so globs are written in lowercase, and quoted in YAML, which reads a bare `*` as an alias. A file no glob matches weighs nothing. Where several globs of `weights` match a file, the most specific wins:
 
 1. A glob with a `/` wins over any glob without one, so `generated/**: 0` weighs every file under `generated/` nothing, `.py`, `.proto` and `.graphql` alike.
-2. Between two globs with a `/`: the one with more segments free of wildcards (`src/legacy/**` over `src/**`), then the one with more segments, then the one with more literal characters (any but `*`, `?` and `/`).
+2. Between two globs with a `/`, in this order:
+   1. the one with more segments free of wildcards (`src/legacy/**` over `src/**`);
+   2. then the one with fewer `**` segments (`src/main.py` over `src/**/main.py`, `a/b/*.ts` over `a/**/b/*.ts`);
+   3. then the one with fewer other segments holding a wildcard;
+   4. then the one with more segments;
+   5. then the one with more literal characters (any but `*`, `?` and `/`).
 3. Between two globs without a `/`: the one with more literal characters (`*.min.js` over `*.js`).
 4. Any tie: the glob first in alphabetical order.
 
-The meter checks each path only against the globs that could match it (those under its first directory, those for its extension, and the few others) and weighs each path once a run.
+The meter files each glob once and checks a path only against the globs that could match it, then weighs each path once a run:
+
+| A glob… | is checked against |
+|---|---|
+| that names one file (`makefile`) | that name |
+| of one name with an extension (`*.py`, `test_?*.py`) | names with that extension |
+| of one name with three literal characters in a row (`*fixture*`) | names holding them |
+| with a `/` whose first segment is a name (`src/**`) | paths under that directory |
+| with a `/` and a segment that is a name (`**/vendored/**`) | paths holding that segment |
+| with a `/` whose last segment has an extension (`*/*.py`) | names with that extension |
+| with a `/` and three literal characters in a row (`**/*_gen*`) | paths holding them |
+
+Any other glob (`*/*`, `*x*`) is checked against every path, so a write may hold at most 16 of them in `weights`, and 16 in `test_files`, counted with what it inherits.
 
 **Layers.** An organization's layer may set every key but `enabled` and `interval_hours`, for its repositories: what counts as code, how fast its team attends to it, where its levels fall, its judge's guidance, its own bots and a narrower forge budget. A repository's layer may set what counts as code in its own layout: `weights`, `excluded_dirs`, `test_dirs`, `test_files` and `test_marks`.
 
 - `weights` is merged glob by glob, through every layer: a document adds or changes the globs it names and keeps every other, so a glob set to `0` stops counting.
-- `bots` and `ai_agents` add to what a layer inherits: a bot the deployment lists counts for every organization, and no layer takes one out.
+- `bots` and `ai_agents` add to what a layer inherits: a bot the deployment lists counts for every organization, and no layer takes one out. A bot spelled otherwise (`CI-Bot`, `ci-bot`) is the same bot, kept once.
+- **Counts.** A write is refused (422, naming the key and the count) when `weights`, `bots` or `ai_agents`, merged with what it inherits, would hold more than the key may (1000 globs, 200 bots, 200 agents). When a document below grows later, a layer read past the bound keeps every entry of its own, and the inherited ones that fit, in their order, with a warning (`settings_layer_entries_left_out`): never only the inherited list.
 - `excluded_dirs` and the `test_*` lists replace what they inherit whole, so a repository can take back a directory the default excludes (a `deps/` of its own code), restating the rest.
 - Every other key a layer sets replaces the inherited value.
-- **The forge budget.** A credential's budget is the deployment's `api_calls_per_tick` and `rate_reserve`. An organization's values only narrow its own repositories' share of it: fewer calls, or a larger reserve they stop at. They never widen it, and never lower what another organization reading with the same credential gets.
+- **The forge budget.** A credential's budget is the deployment's `api_calls_per_tick` and `rate_reserve`. An organization's values only narrow its own repositories' share of it: fewer calls, or a larger reserve they stop at. They never widen it, and never lower what another organization reading with the same credential gets. A repository stopped only by its organization's share is scored with the events it read, and reads on from where it stopped at the next run; only the credential's own budget running out brings the meter back sooner (`SLOP_METER_CATCHUP_SECONDS`).
 
 **Before this section.** `SLOP_METER_INTERVAL_SECONDS` (`0` turned the reading off), `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE` are imported once, at the first start of the release that added the section, as `interval_hours` (or `enabled: false`), `api_calls_per_tick` and `rate_reserve`, and ignored after that. Each organization's `slop_meter_bots` was copied into its layer as `bots` ([api.md](api.md#organizations)). Everything else was a constant in the meter's code, and its default is that constant.
 
diff --git a/embry0/services/slop_meter/globs.py b/embry0/services/slop_meter/globs.py
index fbae4f54..350c47eb 100644
--- a/embry0/services/slop_meter/globs.py
+++ b/embry0/services/slop_meter/globs.py
@@ -23,7 +23,7 @@
 import functools
 import re
 from collections.abc import Iterable
-from typing import Final
+from typing import Any, Final
 
 MAX_GLOB_LENGTH: Final = 200
 MAX_DIR_LENGTH: Final = 100
@@ -133,23 +133,29 @@ def marked(name: str, marks: frozenset[str]) -> bool:
     return bool(stem) and "." in stem and word in marks
 
 
-def specificity(glob: str) -> tuple[int, int, int, int]:
+def specificity(glob: str) -> tuple[int, ...]:
     """How specific ``glob`` is, larger the more specific; where several globs match one file, the most specific
     is the one that counts (:class:`GlobIndex`).
 
     A glob with a ``/`` is more specific than any glob without one. Between two
-    with a ``/``: the one with more segments free of wildcards, then the one with
-    more segments, then the one with more literal characters. Between two
-    without: the one with more literal characters, so ``*.min.js`` is more
-    specific than ``*.js``. A literal character is any but ``*``, ``?`` and ``/``.
+    with a ``/``: the one with more segments free of wildcards; then the one
+    with fewer ``**`` segments; then the one with fewer other segments holding a
+    wildcard; then the one with more segments; then the one with more literal
+    characters. So ``src/main.py`` is more specific than ``src/**/main.py``,
+    ``src/*/main.py`` than ``src/**/main.py``, and ``src/legacy/**`` than
+    ``src/**``. Between two without a ``/``: the one with more literal
+    characters, so ``*.min.js`` is more specific than ``*.js``. A literal
+    character is any but ``*``, ``?`` and ``/``.
     """
     lowered = glob.lower()
     literal = sum(1 for char in lowered if char not in "*?/")
     if "/" not in lowered:
-        return (0, literal, 0, 0)
+        return (0, literal, 0, 0, 0, 0)
     segments = lowered.split("/")
     plain = sum(1 for segment in segments if not any(char in segment for char in "*?"))
-    return (1, plain, len(segments), literal)
+    deep = sum(1 for segment in segments if segment == "**")
+    wild = len(segments) - plain - deep
+    return (1, plain, -deep, -wild, len(segments), literal)
 
 
 #: A glob's place among others: :func:`specificity`, the most specific first, then the glob's text.
@@ -161,72 +167,172 @@ def _order(glob: str) -> _Order:
     return tuple(-part for part in specificity(glob)), glob.lower()
 
 
+_WILD: Final = re.compile(r"[*?]+")
+#: The length of the runs of literal characters a glob is filed under when nothing more selective is there.
+GRAM: Final = 3
+#: The most globs a list may hold that :class:`GlobIndex` can file under nothing: no literal first directory,
+#: no literal segment, no extension and no three literal characters in a row (``*/*``, ``*x*``). Each of
+#: them is checked against every path.
+MAX_BROAD_GLOBS: Final = 16
+
+
+def _plain(text: str) -> bool:
+    return not any(char in text for char in "*?")
+
+
+def _extension_of(text: str) -> str | None:
+    """The extension a name matching ``text`` (a glob of one name) must have, or None when it may have any: the
+    part after the last ``.`` of the literal after the glob's last wildcard."""
+    tail = _WILD.split(text)[-1]
+    return tail.rpartition(".")[2] if "." in tail else None
+
+
+def _runs(text: str) -> list[str]:
+    """The runs of literal characters of a glob, within its segments."""
+    return [run for segment in text.split("/") for run in _WILD.split(segment) if len(run) >= GRAM]
+
+
+def bucket(glob: str) -> tuple[str, str]:
+    """Where :class:`GlobIndex` files ``glob``: ``(kind, key)``.
+
+    A name: ``exact``, under itself. A glob of one name with an extension
+    (``*.py``, ``test_?*.py``): ``extension``. Another with three literal
+    characters in a row (``*fixture*``): ``gram``, under one of its runs. A
+    glob with a ``/`` whose first segment is a name: ``head``; else one with a
+    segment that is a name (``**/vendored/**``): ``segment``, under its
+    longest; else one whose last segment has an extension (``*/*.py``):
+    ``path-extension``; else three literal characters: ``path-gram``. Any
+    other glob is ``broad``, checked against every path.
+    """
+    lowered = glob.lower()
+    if "/" not in lowered:
+        if _plain(lowered):
+            return "exact", lowered
+        extension = _extension_of(lowered)
+        if extension is not None:
+            return "extension", extension
+        return ("gram", "") if _runs(lowered) else ("broad", "")
+    segments = lowered.split("/")
+    if _plain(segments[0]):
+        return "head", segments[0]
+    literal = [segment for segment in segments if _plain(segment)]
+    if literal:
+        return "segment", max(reversed(literal), key=len)
+    extension = _extension_of(segments[-1]) if segments[-1] != "**" else None
+    if extension is not None:
+        return "path-extension", extension
+    return ("path-gram", "") if _runs(lowered) else ("broad", "")
+
+
+def broad(glob: str) -> bool:
+    """Whether :class:`GlobIndex` checks ``glob`` against every path (:func:`bucket`)."""
+    return bucket(glob)[0] == "broad"
+
+
+_Entry = tuple[_Order, re.Pattern[str], Any]
+
+
 class GlobIndex[V]:
     """Globs, each with a value, indexed so a path is checked against the few that could match it.
 
     :meth:`best` answers the value of the most specific glob that matches a
     path (:func:`specificity`; a tie goes to the glob first in alphabetical
-    order), or None. A glob ``*`` and a literal holding a ``.`` (``*.py``,
-    ``*_test.go``) is filed under its last extension and checked only against
-    names with that extension; a glob with no wildcard against the one name it
-    is; a glob with a ``/`` whose first segment is a name only against paths
-    under that directory. ``evaluations`` counts the globs checked.
+    order), or None. Each glob is filed once (:func:`bucket`) and checked only
+    against the paths it could match: a name against itself; a glob of one name
+    with an extension against names with it; a glob with a literal first
+    directory against paths under it; one with a literal segment against paths
+    holding that segment; one whose last segment has an extension against
+    names with it; one with three literal characters in a row against paths
+    that hold them. Only a broad glob (:func:`broad`, at most
+    :data:`MAX_BROAD_GLOBS` in a list the section takes) is checked against
+    every path. ``evaluations`` counts the globs checked.
     """
 
     def __init__(self, entries: Iterable[tuple[str, V]]) -> None:
         self._exact: dict[str, tuple[_Order, V]] = {}
-        self._by_extension: dict[str, list[tuple[_Order, str, V]]] = {}
-        self._names: list[tuple[_Order, re.Pattern[str], V]] = []
-        self._by_head: dict[str, list[tuple[_Order, re.Pattern[str], V]]] = {}
-        self._paths: list[tuple[_Order, re.Pattern[str], V]] = []
+        self._suffixes: dict[str, list[tuple[_Order, str, V]]] = {}
+        self._names: dict[str, dict[str, list[_Entry]]] = {"extension": {}, "gram": {}}
+        self._paths: dict[str, dict[str, list[_Entry]]] = {
+            "head": {},
+            "segment": {},
+            "path-extension": {},
+            "path-gram": {},
+        }
+        self._broad_names: list[_Entry] = []
+        self._broad_paths: list[_Entry] = []
         self.evaluations = 0
         for glob, value in sorted(entries, key=lambda entry: _order(entry[0])):
             lowered = glob.lower()
             order = _order(lowered)
-            if "/" in lowered:
-                head = lowered.split("/", 1)[0]
-                wild = any(char in head for char in "*?")
-                target = self._paths if wild else self._by_head.setdefault(head, [])
-                target.append((order, compile_glob(lowered), value))
-            elif not any(char in lowered for char in "*?"):
+            kind, key = bucket(lowered)
+            if kind == "exact":
                 self._exact.setdefault(lowered, (order, value))
-            elif lowered.startswith("*") and "." in lowered and not any(char in lowered[1:] for char in "*?"):
-                extension = lowered.rpartition(".")[2]
-                self._by_extension.setdefault(extension, []).append((order, lowered[1:], value))
+            elif kind == "extension" and lowered.startswith("*") and _plain(lowered[1:]):
+                self._suffixes.setdefault(key, []).append((order, lowered[1:], value))
+            elif kind in ("gram", "path-gram"):
+                table = self._names["gram"] if kind == "gram" else self._paths["path-gram"]
+                # Filed under the run's gram that holds the fewest globs so far, so similar globs spread out.
+                grams = {run[i : i + GRAM] for run in _runs(lowered) for i in range(len(run) - GRAM + 1)}
+                gram = min(sorted(grams), key=lambda g: len(table.get(g, ())))
+                table.setdefault(gram, []).append((order, compile_glob(lowered), value))
+            elif kind == "broad":
+                target = self._broad_paths if "/" in lowered else self._broad_names
+                target.append((order, compile_glob(lowered), value))
             else:
-                self._names.append((order, compile_glob(lowered), value))
+                table = self._names[kind] if kind == "extension" else self._paths[kind]
+                table.setdefault(key, []).append((order, compile_glob(lowered), value))
 
-    def _first(self, candidates: Iterable[tuple[_Order, re.Pattern[str], V]], text: str) -> tuple[_Order, V] | None:
+    def _first(self, candidates: Iterable[_Entry], text: str) -> tuple[_Order, V] | None:
         for order, pattern, value in candidates:
             self.evaluations += 1
             if pattern.fullmatch(text) is not None:
                 return order, value
         return None
 
+    def _best_of(self, lists: Iterable[Iterable[_Entry]], text: str) -> tuple[_Order, V] | None:
+        found = [hit for hit in (self._first(entries, text) for entries in lists) if hit is not None]
+        return min(found, key=lambda item: item[0]) if found else None
+
+    @staticmethod
+    def _grams(text: str) -> set[str]:
+        return {text[i : i + GRAM] for i in range(len(text) - GRAM + 1)}
+
     def best(self, path: str) -> V | None:
         """The value of the most specific glob matching ``path``, lowercased and from the repository's root."""
+        segments = path.split("/")
+        name = segments[-1]
+        extension = name.rpartition(".")[2] if "." in name else None
+        paths = self._paths
+        lists: list[Iterable[_Entry]] = [self._broad_paths]
+        if len(segments) > 1:
+            lists.append(paths["head"].get(segments[0], ()))
+        if paths["segment"]:
+            lists.extend(paths["segment"].get(segment, ()) for segment in set(segments))
+        if extension is not None:
+            lists.append(paths["path-extension"].get(extension, ()))
+        if paths["path-gram"]:
+            lists.extend(paths["path-gram"].get(gram, ()) for gram in self._grams(path))
+        hit = self._best_of(lists, path)
+        if hit is not None:
+            # A glob with a '/' is more specific than any without one.
+            return hit[1]
         found: list[tuple[_Order, V]] = []
-        if "/" in path:
-            hit = self._first(self._by_head.get(path.split("/", 1)[0], ()), path)
-            if hit is not None:
-                found.append(hit)
-        hit = self._first(self._paths, path)
+        exact = self._exact.get(name)
+        if exact is not None:
+            self.evaluations += 1
+            found.append(exact)
+        if extension is not None:
+            for order, suffix, value in self._suffixes.get(extension, ()):
+                self.evaluations += 1
+                if name.endswith(suffix):
+                    found.append((order, value))
+                    break
+        names: list[Iterable[_Entry]] = [self._broad_names]
+        if extension is not None:
+            names.append(self._names["extension"].get(extension, ()))
+        if self._names["gram"]:
+            names.extend(self._names["gram"].get(gram, ()) for gram in self._grams(name))
+        hit = self._best_of(names, name)
         if hit is not None:
             found.append(hit)
-        if not found:
-            # Only when no glob with a '/' matches: any of them is more specific than every glob without one.
-            name = path.rsplit("/", 1)[-1]
-            exact = self._exact.get(name)
-            if exact is not None:
-                self.evaluations += 1
-                found.append(exact)
-            if "." in name:
-                for order, suffix, value in self._by_extension.get(name.rpartition(".")[2], ()):
-                    self.evaluations += 1
-                    if name.endswith(suffix):
-                        found.append((order, value))
-                        break
-            hit = self._first(self._names, name)
-            if hit is not None:
-                found.append(hit)
         return min(found, key=lambda item: item[0])[1] if found else None
diff --git a/embry0/services/slop_meter/loop.py b/embry0/services/slop_meter/loop.py
index 5ee54f9d..21ce0ded 100644
--- a/embry0/services/slop_meter/loop.py
+++ b/embry0/services/slop_meter/loop.py
@@ -254,6 +254,24 @@ def area_of(path: str) -> str | None:
     )
 
 
+def history_of(
+    rows: Iterable[Mapping[str, Any]],
+    event_rows: Iterable[Mapping[str, Any]],
+    bots: frozenset[str],
+    agents: Iterable[str],
+) -> tuple[list[Commit], list[Event]]:
+    """A repository's stored commits and events as a score reads them: each commit with ``bots`` and the AI
+    agents ``agents`` known (:func:`embry0.services.slop_meter.history.with_bots`), and the events of people.
+    Pure: runs in a thread."""
+    commits = with_bots([Commit.from_row(dict(row)) for row in rows], bots, agents)
+    events = [
+        Event(str(e["login"]), e["at"], str(e["kind"]))
+        for e in event_rows
+        if not is_bot(str(e["login"]), "", bots, agents)
+    ]
+    return commits, events
+
+
 def unjudged(inputs: Inputs) -> list[Outlier]:
     """The repository's outlier commits no model has judged yet. Pure: runs in a thread."""
     weigh = weigher_for(inputs.commits, inputs.files, inputs.settings, inputs.rules)
@@ -536,6 +554,14 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
         and never less for another organization's repositories on the same
         credential. One credential running low never stops a repository read
         with another (#185).
+
+        A repository stopped by its credential's own budget or reserve waits:
+        it is scored once its events are read, and the loop comes back after
+        ``catchup_seconds``, as before. One stopped only by its organization's
+        narrower share is scored with what it read and goes on from its
+        cursors at the next run, at the interval: an organization that reads
+        less never holds the meter, and every other organization's
+        repositories, on its catch-up cadence.
         """
         deployment = self._meter.deployment()
         readers: dict[str, EventReader] = {}
@@ -566,14 +592,16 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                     share_of[repo] = shares[(credential, owner)]
         active = list(readers)
         waiting: list[str] = []
+        narrowed: list[str] = []
         while active:
             for repo in list(active):
                 try:
                     going = await readers[repo].step(share_of[repo])
                 except BudgetSpent:
-                    # Its share of its credential's budget is gone; the others' repositories go on.
+                    # Its share is gone; the others' repositories go on. Whose limit stopped it, the
+                    # credential's or only its organization's, is what it is at this moment.
                     active.remove(repo)
-                    waiting.append(repo)
+                    (waiting if share_of[repo].shared.spent else narrowed).append(repo)
                     continue
                 except Exception as exc:  # noqa: BLE001 - this repository's events stop for the tick
                     logger.warning("slop_meter_events_failed", repo=repo, error=str(exc)[:300])
@@ -581,7 +609,7 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                     continue
                 if not going:
                     active.remove(repo)
-        if waiting:
+        if waiting or narrowed:
             spent = [b for b in shares.values() if b.spent]
             logger.info(
                 "slop_meter_api_budget_spent",
@@ -589,6 +617,7 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                 remaining=[b.remaining for b in spent],
                 reserve=[b.reserve for b in spent],
                 waiting=sorted(waiting),
+                narrowed=sorted(narrowed),
             )
         for repo, reader in readers.items():
             batch = reader.batch
@@ -607,12 +636,9 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
     async def _inputs(self, repo: str, settings: SlopMeterSettings) -> Inputs:
         bots = own_identities([*await self._bots(repo), *settings.bots])
         agents = agent_prefixes(settings.ai_agents)
-        commits = with_bots([Commit.from_row(r) for r in await self._store.commits(repo)], bots, agents)
-        events = [
-            Event(str(e["login"]), e["at"], str(e["kind"]))
-            for e in await self._store.events(repo)
-            if not is_bot(str(e["login"]), "", bots, agents)
-        ]
+        rows, event_rows = await self._store.commits(repo), await self._store.events(repo)
+        # Building every commit of a long history takes a while: off the event loop, as the scoring is.
+        commits, events = await asyncio.to_thread(history_of, rows, event_rows, bots, agents)
         files = {name: await self._mirror.read(repo, name) for name in (*CONFIG_FILES, AREAS_PATH)}
         logins, judgments = await self._store.logins(), await self._store.judgments(repo)
         return Inputs(commits, events, logins, judgments, files, settings, FileRules.of(settings))
diff --git a/embry0/settings/document.py b/embry0/settings/document.py
index 81eea4dd..2c7bc67e 100644
--- a/embry0/settings/document.py
+++ b/embry0/settings/document.py
@@ -26,7 +26,7 @@
 import structlog
 import yaml
 
-from embry0.settings.layers import over_default
+from embry0.settings.layers import merged, over_default
 from embry0.settings.registry import (
     DOCUMENT_KEYS,
     MANAGED_BY_FILE,
@@ -251,6 +251,25 @@ def _message(section: Section[Any], error: Mapping[str, Any]) -> str:
     return msg
 
 
+def _too_many(section: Section[Any], error: Mapping[str, Any], count: int | None) -> str:
+    """A merged or added key that holds ``count`` entries, with what it inherits, more than it may."""
+    ctx = error.get("ctx") or {}
+    actual, most = count if count is not None else ctx.get("actual_length"), ctx.get("max_length")
+    if actual is None or most is None:
+        return _message(section, error)
+    return (
+        f"holds {actual} entries together with the ones it inherits (the default's and those of the documents "
+        f"above this one), more than the {most} it may hold"
+    )
+
+
+def _own_values(section: Section[Any], known: Mapping[str, Any]) -> dict[str, Any]:
+    """The keys of ``known`` a document merges or adds to, each as the document's own entries, checked alone:
+    what is stored, never what it inherits."""
+    names = {name: value for name, value in known.items() if name in section.merged_keys | section.added_keys}
+    return section.validate_alone(names) if names else {}
+
+
 def validate_section(section: Section[Any], raw: Mapping[str, Any]) -> SectionModel:
     """``raw`` as the section's model; :class:`SectionRefused` naming each refused key.
 
@@ -463,13 +482,22 @@ def check(
             continue
         base = mapping((inherited or {}).get(key)) if layer != "deployment" else {}
         before = {**base, **{k: v for k, v in kept_section.items() if k in section.model.model_fields}}
+        # A key merged or added to is checked as its readers read it, over what it inherits, so a count the read
+        # could not hold is refused here, naming the key; what is stored is the document's own entries.
+        combined = merged(section, base, known, fit=False)
         try:
             model = section.validate(
-                {**base, **known}, context=None if context is None else {**context, STORED: before}
+                {**base, **combined}, context=None if context is None else {**context, STORED: before}
             )
         except SectionRefused as exc:
             for error in exc.errors:
                 loc = tuple(error.get("loc") or ())
+                spread = loc and str(loc[0]) in known and str(loc[0]) in section.merged_keys | section.added_keys
+                if spread and error.get("type") == "too_long":
+                    entries = combined.get(str(loc[0]))
+                    count = len(entries) if isinstance(entries, list | tuple | dict) else None
+                    problems.append(Problem((key, *loc), "too_long", _too_many(section, error, count)))
+                    continue
                 if layer != "deployment" and not (loc and str(loc[0]) in known):
                     problems.append(
                         Problem(
@@ -481,11 +509,12 @@ def check(
                 else:
                     problems.append(Problem((key, *loc), str(error.get("type")), _message(section, error)))
             continue
+        own = _own_values(section, known)
         if layer == "deployment":
-            clean = {**model.model_dump(mode="json", exclude_unset=True), **kept}
+            clean = {**model.model_dump(mode="json", exclude_unset=True), **own, **kept}
         else:
             dumped = model.model_dump(mode="json")
-            clean = {**{name: dumped[name] for name in known}, **kept}
+            clean = {**{name: dumped[name] for name in known}, **own, **kept}
         if clean:
             data[key] = clean
     if problems:
diff --git a/embry0/settings/layers.py b/embry0/settings/layers.py
index 7b3378e5..be56f2fc 100644
--- a/embry0/settings/layers.py
+++ b/embry0/settings/layers.py
@@ -22,12 +22,17 @@
 
 from __future__ import annotations
 
+import json
 from collections.abc import Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Protocol, runtime_checkable
 
+import structlog
+
 from embry0.settings.registry import Section, SectionModel, SectionRefused
 
+logger = structlog.get_logger(__name__)
+
 
 @runtime_checkable
 class PerRepository[M: SectionModel](Protocol):
@@ -98,11 +103,53 @@ def _reason(errors: Sequence[Mapping[str, Any]], key: str | None) -> str:
     return str((errors[0] if errors else {}).get("msg") or "refused").removeprefix("Value error, ")
 
 
-def merged(section: Section[Any], inherited: Mapping[str, Any], values: Mapping[str, Any]) -> dict[str, Any]:
-    """A document's ``values`` as they apply over ``inherited``: each key of ``section.merged_keys`` it sets, a
-    mapping, holds the section's default entries, then the inherited ones, under its own; each key of
-    ``section.added_keys`` it sets, a list, holds the section's default items, then the inherited ones, then its
-    own, each once; every other key as the document wrote it."""
+def _same(item: Any) -> Any:
+    """What two items of an added list are compared by: text without regard to case, as a list of bots is
+    matched; anything else as JSON writes it."""
+    return item.lower() if isinstance(item, str) else json.dumps(item, sort_keys=True)
+
+
+def cap_of(section: Section[Any], key: str) -> int | None:
+    """The most entries ``key`` of ``section`` holds, as its model's ``max_length`` says; None for no bound."""
+    info = section.model.model_fields.get(key)
+    for meta in getattr(info, "metadata", ()) or ():
+        bound = getattr(meta, "max_length", None)
+        if isinstance(bound, int):
+            return bound
+    return None
+
+
+def _trimmed(section: Section[Any], key: str, below: int, kept: int) -> None:
+    logger.warning(
+        "settings_layer_entries_left_out",
+        section=section.name,
+        key=key,
+        inherited=below,
+        kept=kept,
+        hint="the layer's own entries and the ones it inherits are more than the key holds: every entry of the "
+        "layer's own is kept, and the inherited ones that fit, in their order",
+    )
+
+
+def merged(
+    section: Section[Any], inherited: Mapping[str, Any], values: Mapping[str, Any], *, fit: bool = True
+) -> dict[str, Any]:
+    """A document's ``values`` as they apply over ``inherited``.
+
+    Each key of ``section.merged_keys`` it sets, a mapping, holds the section's
+    default entries, then the inherited ones, under its own. Each key of
+    ``section.added_keys`` it sets, a list, holds the section's default items,
+    then the inherited ones, then its own, each once (text without regard to
+    case: the first spelling stays). Every other key is as the document wrote
+    it.
+
+    ``fit`` is how a read takes a key that, so merged, holds more entries than
+    its ``max_length``, as when the document below it grew after the layer was
+    written: every entry the document names itself is kept, and the inherited
+    ones that fit, in their order, the rest left out with a warning
+    (``settings_layer_entries_left_out``). A write checks with ``fit`` false,
+    so the same count is refused there, naming the key.
+    """
     out = dict(values)
     defaults: dict[str, Any] | None = None
     for key in section.added_keys & set(values):
@@ -110,28 +157,65 @@ def merged(section: Section[Any], inherited: Mapping[str, Any], values: Mapping[
         if not isinstance(own, list | tuple):
             continue
         defaults = defaults if defaults is not None else section.defaults().model_dump(mode="json")
-        items: list[Any] = []
-        for layer in (defaults.get(key), inherited.get(key), own):
+        below: list[Any] = []
+        seen: set[Any] = set()
+        for layer in (defaults.get(key), inherited.get(key)):
             if isinstance(layer, list | tuple):
-                items.extend(item for item in layer if item not in items)
+                for item in layer:
+                    if _same(item) not in seen:
+                        seen.add(_same(item))
+                        below.append(item)
+        mine: list[Any] = []
+        named: set[Any] = set()
+        for item in own:
+            if _same(item) not in named:
+                named.add(_same(item))
+                mine.append(item)
+        items = below + [item for item in mine if _same(item) not in seen]
+        cap = cap_of(section, key)
+        if fit and cap is not None and len(items) > cap:
+            room = cap - len(mine)
+            trimmed: list[Any] = []
+            for item in below:
+                if _same(item) in named:
+                    trimmed.append(item)
+                elif room > 0:
+                    trimmed.append(item)
+                    room -= 1
+            trimmed.extend(item for item in mine if _same(item) not in seen)
+            _trimmed(section, key, len(below), len(trimmed))
+            items = trimmed
         out[key] = items
     for key in section.merged_keys & set(values):
         own = values[key]
         if not isinstance(own, Mapping):
             continue
         defaults = defaults if defaults is not None else section.defaults().model_dump(mode="json")
-        below: dict[str, Any] = {}
+        entries: dict[str, Any] = {}
         for layer in (defaults.get(key), inherited.get(key)):
             if isinstance(layer, Mapping):
-                below.update(layer)
-        out[key] = {**below, **own}
+                entries.update(layer)
+        cap = cap_of(section, key)
+        if fit and cap is not None and len({**entries, **own}) > cap:
+            room = cap - len(own)
+            kept: dict[str, Any] = {}
+            for name, value in entries.items():
+                if name in own:
+                    continue
+                if room <= 0:
+                    break
+                kept[name] = value
+                room -= 1
+            _trimmed(section, key, len(entries), len(kept) + len(own))
+            entries = kept
+        out[key] = {**entries, **own}
     return out
 
 
-def over_default(section: Section[Any], values: Mapping[str, Any]) -> dict[str, Any]:
+def over_default(section: Section[Any], values: Mapping[str, Any], *, fit: bool = True) -> dict[str, Any]:
     """The deployment's stored ``values`` as its readers read them: each merged key over the section's default
-    entries, so writing one entry never drops the others' defaults."""
-    return merged(section, {}, values)
+    entries, so writing one entry never drops the others' defaults. ``fit`` as :func:`merged` takes it."""
+    return merged(section, {}, values, fit=fit)
 
 
 def resolve(
diff --git a/embry0/settings/registry.py b/embry0/settings/registry.py
index 670ae508..389add51 100644
--- a/embry0/settings/registry.py
+++ b/embry0/settings/registry.py
@@ -229,8 +229,11 @@ class Section[M: SectionModel]:
     of the same name below, and every other entry stays), each one also in
     ``org_keys`` or ``repo_keys``. ``added_keys`` are list fields a document
     adds to what is below it the same way: the deployment's items after the
-    field's default ones and a layer's after what it inherits, each item once,
-    so no layer takes an item out of the list below it.
+    field's default ones and a layer's after what it inherits, each item once
+    (text without regard to case), so no layer takes an item out of the list
+    below it. A write counts either kind with what it inherits against the
+    field's ``max_length``; a read past it keeps the document's own entries
+    and the inherited ones that fit (:func:`embry0.settings.layers.merged`).
     ``env`` maps a field to the ``Embry0Config`` attribute its value is
     imported from, once (``embry0.settings.bootstrap``): a string is the
     attribute, an :class:`EnvImport` adds a converter, the parts it drops, or a
diff --git a/embry0/settings/sections/slop_meter.py b/embry0/settings/sections/slop_meter.py
index 6fb71461..1b1b658a 100644
--- a/embry0/settings/sections/slop_meter.py
+++ b/embry0/settings/sections/slop_meter.py
@@ -57,14 +57,18 @@
 import hashlib
 import json
 import unicodedata
+from collections.abc import Iterable
 from typing import Annotated, Any, Final
 
-from pydantic import Field, StringConstraints, field_validator, model_validator
+from pydantic import Field, StringConstraints, ValidationInfo, field_validator, model_validator
 
 from embry0.services.slop_meter.globs import (
+    GRAM,
+    MAX_BROAD_GLOBS,
     MAX_DIR_LENGTH,
     MAX_GLOB_LENGTH,
     MAX_MARK_LENGTH,
+    broad,
     check_dir_name,
     check_glob,
     check_mark,
@@ -169,6 +173,24 @@ def _each(values: tuple[str, ...], check: Any, what: str) -> tuple[str, ...]:
     return values
 
 
+def _few_broad(globs: Iterable[str], info: ValidationInfo) -> None:
+    """Refuse, on a write, more broad globs than :data:`MAX_BROAD_GLOBS`: each is checked against every path.
+
+    Checked when a write is stored (it carries a validation context), with what
+    the key inherits, never when a stored value is read: a document below that
+    grows later never makes a layer's globs read as refused.
+    """
+    if info.context is None:
+        return
+    count = sum(1 for glob in globs if broad(glob))
+    if count > MAX_BROAD_GLOBS:
+        raise ValueError(
+            f"{count} globs, with the ones inherited, name no literal directory, no extension and no "
+            f"{GRAM} literal characters in a row (such as */* or *x*); at most {MAX_BROAD_GLOBS}, since each is "
+            "checked against every path"
+        )
+
+
 def _identity(text: str) -> str:
     if not text.strip():
         raise ValueError("write a name, an address or a login, not blanks")
@@ -241,11 +263,14 @@ class SlopMeterSettings(SectionModel):
             "(*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' "
             "matches within one name, '?' one character, '**' any directories. Where several match, the most "
             "specific wins: a glob with a '/' over any without one; between two with one, more segments free of "
-            "wildcards, then more segments, then more literal characters; between two without, more literal "
-            "characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every "
-            "file under generated/, whatever its kind. Write globs in lowercase, quoted: matching ignores case, "
+            "wildcards, then fewer ** segments, then fewer other segments with a wildcard, then more segments, "
+            "then more literal characters; between two without, more literal characters (*.min.js over *.js); "
+            "then the first in alphabetical order. So generated/** weighs every file under generated/, whatever "
+            "its kind, and src/main.py wins over src/**/main.py. At most 16 globs that name no literal "
+            "directory, no extension and no three literal characters in a row (*/*, *x*). Write globs in lowercase, quoted: matching ignores case, "
             "and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it "
-            "names and keeps every other, so a glob set to 0 stops counting."
+            "names and keeps every other, so a glob set to 0 stops counting; at most 1000 globs in all, counted "
+            "with the defaults and what a write inherits."
         ),
     )
     excluded_dirs: tuple[DirName, ...] = Field(
@@ -435,8 +460,8 @@ class SlopMeterSettings(SectionModel):
             "add lines but no attention, and as a co-author they count as an AI agent does. Beyond the ones every "
             "deployment knows ([bot] accounts, noreply@ addresses, known coding agents) and embry0's own commit "
             "identities. Each document adds to the list it inherits, so a bot the deployment lists counts for "
-            "every organization; no layer takes one out. At most 200 in all. Was the organization's "
-            "slop_meter_bots."
+            "every organization; no layer takes one out, and a bot spelled otherwise is the same one. At most 200 "
+            "in all, counted with what a write inherits. Was the organization's slop_meter_bots."
         ),
     )
     ai_agents: tuple[Identity, ...] = Field(
@@ -446,13 +471,14 @@ class SlopMeterSettings(SectionModel):
             "AI coding agents beyond the known ones, each its commit address up to and including the @ (aider@, "
             "any domain) or a whole address (agent@tools.example), matched without regard to case: a commit one "
             "authors adds lines but no attention, and one it co-authors counts ai_coauthor_share of its author's "
-            "hours. Each document adds to the list it inherits, as bots. At most 200 in all."
+            "hours. Each document adds to the list it inherits, as bots. At most 200 in all, counted with what a write "
+            "inherits."
         ),
     )
 
     @field_validator("weights")
     @classmethod
-    def _weights(cls, value: dict[str, float]) -> dict[str, float]:
+    def _weights(cls, value: dict[str, float], info: ValidationInfo) -> dict[str, float]:
         for position, (glob, weight) in enumerate(value.items(), start=1):
             try:
                 check_glob(glob)
@@ -460,6 +486,7 @@ def _weights(cls, value: dict[str, float]) -> dict[str, float]:
                 raise ValueError(f"glob {position}: {exc}") from None
             if not 0 <= weight <= 10:
                 raise ValueError(f"glob {position}: a weight is from 0 to 10")
+        _few_broad(value, info)
         return value
 
     @field_validator("excluded_dirs", "test_dirs")
@@ -469,8 +496,10 @@ def _dirs(cls, value: tuple[str, ...]) -> tuple[str, ...]:
 
     @field_validator("test_files")
     @classmethod
-    def _test_files(cls, value: tuple[str, ...]) -> tuple[str, ...]:
-        return _each(value, check_glob, "glob")
+    def _test_files(cls, value: tuple[str, ...], info: ValidationInfo) -> tuple[str, ...]:
+        _each(value, check_glob, "glob")
+        _few_broad(value, info)
+        return value
 
     @field_validator("test_marks")
     @classmethod
diff --git a/tests/unit/services/slop_meter/test_loop_settings.py b/tests/unit/services/slop_meter/test_loop_settings.py
index 80cab408..f7fb59b0 100644
--- a/tests/unit/services/slop_meter/test_loop_settings.py
+++ b/tests/unit/services/slop_meter/test_loop_settings.py
@@ -285,6 +285,36 @@ async def read_with(section: Section, found: dict[str, Any], tokens: Mapping[str
     )
 
 
+@pytest.mark.parametrize(
+    "narrower", [{"api_calls_per_tick": 0}, {"api_calls_per_tick": 3}, {"rate_reserve": 100_000}], ids=str
+)
+async def test_an_organization_that_reads_less_never_holds_the_meter_on_catch_up(narrower: dict[str, int]) -> None:
+    """A repository stopped only by its organization's narrower share is scored with what it read and goes on at the
+    next run: six hours of looks at a 24-hour interval are one full run, one fetch of the other organization."""
+    acme, globex = "acme/app", "globex/app"
+    records, order = fakes._history(2)
+    forges = {name: fakes.FakeForge(comment_pages=1, repo=name) for name in (acme, globex)}
+    store, mirror, clock = fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW]
+    loop = _loop(Section({}, acme=narrower), store, mirror, clock, repos=(acme, globex), forges=forges)
+    runs = []
+    for _ in range(72):
+        runs.append(await loop.scheduled())
+        clock[0] += timedelta(minutes=5)
+    assert runs.count("run") == 1, f"one full run in six hours, not one every catch-up: {runs.count('run')}"
+    assert [repo for repo, _ in mirror.synced].count(globex) == 1, "globex is fetched once"
+    assert acme in store.stored and globex in store.stored, "and acme is scored with the events it read"
+
+
+async def test_the_credential_s_own_budget_still_holds_the_meter_on_catch_up() -> None:
+    """The deployment's budget running out is a backlog, as before: the repository is scored once its events
+    are read (#396 is the separate matter of many repositories on one credential)."""
+    records, order = fakes._history(2)
+    forges = {REPO: fakes.FakeForge(comment_pages=50, repo=REPO)}
+    store = fakes.FakeStore()
+    loop = _loop(Section({"api_calls_per_tick": 3}), store, fakes.FakeMirror(records, order), [NOW], forges=forges)
+    assert await loop.tick() is True and REPO not in store.stored, "a backlog: not scored until its events are read"
+
+
 async def test_the_section_s_bots_and_ai_agents_are_bots_when_scored(monkeypatch: pytest.MonkeyPatch) -> None:
     def record(sha: str, hours: int, email: str, body: str = "Work") -> str:
         at = fakes.START + timedelta(hours=hours)
@@ -336,8 +366,9 @@ async def spy(function: Any, *args: Any) -> Any:
     loop = _loop(section, fakes.FakeStore(), fakes.FakeMirror(records, order), [NOW], model="custom/local")
     await loop.tick()
     assert heard == ["Imports under third_party are never slop."], f"the owner's guidance reached the judge: {heard}"
-    assert threaded == ["unjudged", "compute"], (
-        f"finding the outliers to judge weighs every path, so it runs in a thread, as the scoring does: {threaded}"
+    assert threaded == ["history_of", "unjudged", "compute"], (
+        "building the history, finding the outliers to judge and scoring each go through every commit or path, "
+        f"so each runs in a thread: {threaded}"
     )
 
 
diff --git a/tests/unit/services/slop_meter/test_scoring_settings.py b/tests/unit/services/slop_meter/test_scoring_settings.py
index af7a0a71..90855e22 100644
--- a/tests/unit/services/slop_meter/test_scoring_settings.py
+++ b/tests/unit/services/slop_meter/test_scoring_settings.py
@@ -284,24 +284,70 @@ def test_the_most_specific_glob_wins_and_a_glob_with_a_slash_matches_from_the_ro
     assert type_weight("README.md", rules) == 0.0, "a file no glob matches weighs nothing"
 
 
-def test_a_path_is_checked_against_the_few_globs_that_could_match_it() -> None:
-    """20,000 paths under 200 directories, against the default globs and 900 globs of other directories: each
-    path is checked against a handful, not against every glob, and each path once however often it is asked."""
+def test_an_exact_path_wins_over_one_that_reaches_it_through_wildcards() -> None:
+    rules = _rules({"weights": {"src/**/main.py": 0.1, "src/main.py": 2.0, "docs/**/api.md": 0.1, "docs/api.md": 2.0}})
+    assert type_weight("src/main.py", rules) == 2.0, "src/main.py over src/**/main.py"
+    assert type_weight("src/app/main.py", rules) == 0.1, "which still weighs main.py deeper down"
+    assert type_weight("docs/api.md", rules) == 2.0, "docs/api.md over docs/**/api.md"
+    nested = _rules({"weights": {"a/**/b/*.ts": 0.1, "a/b/*.ts": 2.0}})
+    assert type_weight("a/b/c.ts", nested) == 2.0 and type_weight("a/x/b/c.ts", nested) == 0.1, (
+        "a/b/*.ts over a/**/b/*.ts where both match"
+    )
+
+
+@pytest.mark.parametrize(
+    "globs",
+    [
+        {f"x{i}/legacy/**": 0.0 for i in range(900)},
+        {f"**/d{i}/**": 0.0 for i in range(900)},
+        {f"*/x{i}/*.py": 0.0 for i in range(900)},
+        {f"*x{i}x*": 0.0 for i in range(900)},
+        {f"**/*_gen{i}*": 0.0 for i in range(900)},
+    ],
+    ids=[
+        "literal head",
+        "wildcard head, literal segment",
+        "wildcard head, extension",
+        "name, inner text",
+        "path, inner text",
+    ],
+)
+def test_a_path_is_checked_against_the_few_globs_that_could_match_it(globs: dict[str, float]) -> None:
+    """20,000 paths under 200 directories, against the default globs and 900 more: each path is checked against a
+    handful, not against every glob, whether a glob starts with a directory, a wildcard or neither, and each path
+    once however often it is asked."""
     rng = random.Random(3)
     extensions = ("py", "ts", "js", "go", "rs", "java", "md", "json", "tsx", "css", "proto", "swift")
     paths = [f"d{rng.randrange(200)}/s{rng.randrange(50)}/f{i}.{rng.choice(extensions)}" for i in range(20_000)]
-    rules = _rules({"weights": {f"x{i}/legacy/**": 0.0 for i in range(900)}})
+    rules = _rules({"weights": globs})
     weigh = Weigher(rules=rules)
     for path in paths + paths:
         weigh(path)
     for path in paths:
         type_weight(path, rules)
-    assert rules.evaluations < 5 * len(paths), (
+    assert rules.evaluations < 8 * len(paths), (
         f"{rules.evaluations} glob checks for {len(paths)} paths: a path is checked against every glob, or more "
         "than once"
     )
 
 
+def test_globs_checked_against_every_path_are_bounded_when_written() -> None:
+    from embry0.services.slop_meter.globs import MAX_BROAD_GLOBS, broad
+
+    assert broad("*/*") and broad("*x*") and not broad("**/vendored/**") and not broad("*fixture*")
+    many = {f"*{chr(97 + i % 26)}{i // 26}*": 0.0 for i in range(MAX_BROAD_GLOBS + 1)}
+    assert all(broad(glob) for glob in many)
+    section = CATALOG.get("slop_meter")
+    assert section is not None
+    from embry0.settings.registry import SectionRefused
+
+    with pytest.raises(SectionRefused, match="checked against every path"):
+        section.validate({"weights": many}, context={})
+    assert len(section.validate({"weights": many}).weights) == len(many), (
+        "a stored value is never refused for it when read: a document below that grows later costs time, not the key"
+    )
+
+
 def test_what_a_test_is_and_what_it_weighs() -> None:
     assert type_weight("pkg/a_test.go") == 0.5
     full = _rules({"test_weight": 1.0})
diff --git a/tests/unit/settings/test_slop_meter_section.py b/tests/unit/settings/test_slop_meter_section.py
index eec27e86..52f7c2a1 100644
--- a/tests/unit/settings/test_slop_meter_section.py
+++ b/tests/unit/settings/test_slop_meter_section.py
@@ -348,3 +348,65 @@ def test_the_section_reads_as_an_operator_writes_it() -> None:
         "level_names": ["Clean", "Fine", "Mixed", "Sloppy", "Slop"],
         "bots": ["release-bot", "ci@acme.example"],
     }, data
+
+
+# ---- caps of keys merged over what they inherit ----
+
+
+def _layer_problems(values: Mapping[str, Any], inherited: Mapping[str, Any]) -> dict[str, str]:
+    """Each key an organization's layer writing ``values`` over ``inherited`` is refused at, with its message."""
+    _section()
+    try:
+        check(
+            CATALOG,
+            {"slop_meter": dict(values)},
+            stored={},
+            layer="organization",
+            inherited={"slop_meter": dict(inherited)},
+        )
+    except DocumentInvalid as exc:
+        return {".".join(str(part) for part in problem.loc[1:]): problem.msg for problem in exc.problems}
+    return {}
+
+
+def test_a_list_added_to_is_counted_with_what_it_inherits_when_written() -> None:
+    deployment = [f"dep-bot-{i}" for i in range(150)]
+    problems = _layer_problems({"bots": [f"org-bot-{i}" for i in range(60)]}, {"bots": deployment})
+    assert "holds 210 entries together with the ones it inherits" in problems.get("bots", ""), problems
+    variants = [name.upper() for name in deployment[:50]] + [f"org-bot-{i}" for i in range(50)]
+    assert _layer_problems({"bots": variants}, {"bots": deployment}) == {}, (
+        "a bot spelled otherwise is the same bot, as matching ignores case: 200, not 250"
+    )
+
+
+def test_globs_are_counted_with_the_defaults_and_what_they_inherit_when_written() -> None:
+    assert _layer_problems({"weights": {f"proj{i}/**": 0.0 for i in range(900)}}, {}) == {}, "979 with the defaults"
+    problems = _layer_problems({"weights": {f"proj{i}/**": 0.0 for i in range(990)}}, {})
+    assert "holds 1069 entries together with the ones it inherits" in problems.get("weights", ""), problems
+    deployment_problems = _problems({"weights": {f"proj{i}/**": 0.0 for i in range(990)}})
+    assert "holds 1069 entries" in deployment_problems.get("weights", ""), "the deployment's, over the defaults"
+
+
+def test_a_layer_keeps_its_own_entries_when_the_document_below_grows_past_the_cap() -> None:
+    """Written within the cap, the organization's list then meets a deployment that grew: every entry of its own
+    is still read, with the inherited ones that fit, never the inherited list alone."""
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    snapshot = _snapshot(
+        {
+            "deployment": {"bots": [f"dep-bot-{i}" for i in range(190)]},
+            "organization:acme": {
+                "bots": [f"org-bot-{i}" for i in range(60)],
+                "weights": {f"proj{i}/**": 0.0 for i in range(990)},
+                "lines_per_hour": 20,
+            },
+        }
+    )
+    widgets = snapshot.resolve(SLOP_METER, repo=WIDGETS)
+    assert widgets.refused == (), f"nothing of acme's layer is refused: {widgets.refused}"
+    bots = widgets.model.bots
+    assert len(bots) == 200 and all(f"org-bot-{i}" in bots for i in range(60)), "all 60 of acme's own bots"
+    assert bots[:140] == tuple(f"dep-bot-{i}" for i in range(140)), "and the deployment's that fit, in order"
+    weights = widgets.model.weights
+    assert len(weights) == 1000 and all(f"proj{i}/**" in weights for i in range(990)), "all of acme's own globs"
+    assert widgets.model.lines_per_hour == 20, "and the rest of its layer"

From f63f5802f47db34a726b60a73cea31a8f32efdd0 Mon Sep 17 00:00:00 2001
From: Tomas McMonigal <74835766+sudoTomas@users.noreply.github.com>
Date: Fri, 6 Nov 2026 16:01:56 +0000
Subject: [PATCH 4/4] feat(slop): the Slop-O-Meter's scoring as a settings
 section

The meter kept all of its policy in code: the file weights and which
directories are vendored or tests, the pace and cap constants, the
small-repository rule, the level bounds and names and the judge's
prompt. An organization could not say what counts as code, how fast
its team works or where its levels fall, and changing a constant
silently rescored every repository. Its reading pace was three
variables, and an owner's own bots sat on its organization row.

Add a `slop_meter` section to the settings document. Every constant is
a key whose default is the value the code held, so nothing written
scores bit for bit as before: a fixture history reproduces the pinned
pre-change numbers, and 86,000 paths weigh what the old rules gave
them. An organization's layer may set every key but `enabled` and
`interval_hours`; a repository's what counts as code in its layout.
`weights` maps a glob to a weight, merged glob by glob through every
layer. Weigh paths by specificity: a folder glob beats any extension
glob, then more literal segments, fewer `**` and wildcard segments,
more segments, more literal characters. Globs are indexed by name,
extension, literal directory or segment and three-character runs; at
most 16 per list may be checked against every path. Each path is
weighed once a run, and the history, outliers and scores are built in
a thread.

Each score row records `config_version` (migration 144), a digest of
the keys its repository's score is computed from. The loop looks at
the section every five minutes: a settings change rescores only the
repositories it touches, from the rows and mirrors already read, with
no fetch, forge call or judgment, and the full run keeps its interval.
`enabled` and `interval_hours` apply within the look. A credential's
forge budget is the deployment's; an organization's values only narrow
its own share. A repository that share stops before its events are all
read keeps its previous score, since a run starts its reading over, and
waits for the next run without keeping the meter on catch-up. `bots` and
`ai_agents` add to what each layer inherits (a new `added_keys` for
list fields, each item once without regard to case), and an AI agent
is an address or the part of one up to its `@`. A write counts merged
and added keys with what they inherit and is refused only when it makes
an over-bound total larger; a read past the bound keeps the most
specific layers' entries first.

SLOP_METER_INTERVAL_SECONDS (0 is `enabled: false`),
SLOP_METER_API_CALLS_PER_TICK and SLOP_METER_RATE_RESERVE are imported
once and read as before until the import succeeds. The organization
setting `slop_meter_bots` moves into its layer as `bots`, cleaned
(each bot once, unholdable entries left out) at the first start and on
PATCH or POST /orgs, which still take it until 0.2.0. The process
limits stay variables. The unread LEAN_LEVEL constant is deleted:
triage's lean belongs to the routing section a later pull request
adds. Multi-line texts in the settings YAML are written as literal
blocks; progression packs keep their own writer.

Refs #169
---
 docs/configuration.md                         |   4 +-
 docs/examples/settings.yaml                   |   6 +-
 docs/slop-meter.md                            |   9 +-
 embry0/services/slop_meter/loop.py            |  33 +++-
 embry0/settings/document.py                   |  38 ++++-
 embry0/settings/layers.py                     | 146 ++++++++++--------
 embry0/settings/registry.py                   |   6 +-
 embry0/settings/sections/slop_meter.py        |  18 ++-
 .../services/slop_meter/test_loop_settings.py |  49 +++++-
 .../unit/settings/test_slop_meter_section.py  |  63 ++++++++
 10 files changed, 284 insertions(+), 88 deletions(-)

diff --git a/docs/configuration.md b/docs/configuration.md
index 386e7873..9ee78522 100644
--- a/docs/configuration.md
+++ b/docs/configuration.md
@@ -307,7 +307,7 @@ asks:
 - **In the dashboard**, Settings → Policy holds the same three things, for one document at a time. The **Layer** picker above them chooses the deployment's document, an organization's layer or a repository's: it offers every organization and repository the lists show and every stored layer, each marked with how many keys its layer sets, and keeps the choice in the URL (`/settings?tab=policy&owner=acme`, `&repo=acme/widgets`), so a layer can be linked to; an organization's Settings tab and a repository's page link to their own. Picking one with no layer opens an empty one that its first save creates, and picking another while an edit is unsaved asks first. The document is a YAML text box: **Preview** runs the dry run and lists each key the text would change, before and after, with the text diff; **Save** then stores exactly the previewed text, with an optional reason. Both name the generation the edit started from (0 for a layer nobody wrote), so if someone else saved in between they are refused, the new version is read in and your text stays in the box to preview again. A layer lists above its text the keys it may set, per section. A refused document lists every problem next to the text, each with its key, and marks a key the layer may not set. When a save, its preview or an undo makes values of the layers under the document read as inherited (`layers_refused`), the tab lists them, each linked to its layer. Below it, **Values in effect** shows every key of every section with its value, its default and where it came from, and warns when a stored value is refused, an imported variable is still set, or the document holds a section or key this release does not know; for a layer, as that organization or repository reads it: the layer each value comes from, what the layer's own value overrides ("Overrides "09-18" from the deployment"), what it inherits and from whom, and, dimmed, the keys it may not set. **History** lists the document's revisions, opens each one to show what it changed, and offers Undo on the newest. Anyone signed in can read the tab, with the people behind changes shown as the audit log shows them (someone else's name only to an admin); only an admin can preview, save or undo, and an API key with a repository allowlist only on a repository's layer the list covers. A document [kept in a file](#from-a-file-the-command-line-and-mcp) is shown read-only, to an admin too.
 - **From the environment.** When a release moves a feature's policy into a section, the first start of that release imports each of its variables you set, when the value differs from the default, once per key (source `bootstrap`); a key a later release adds to the section is imported at that release's first start. A variable left at its default is not imported, so a default the section changes reaches every deployment that never set it; where a section turns a default the other way on purpose, it declares the value a deployment that relied on the old meaning keeps, and how to tell one from its records (for `leads.enabled`: a registered repository, a job or a lead a finder stored). Only records older than the moment the release first asked about the key count: the import records that moment once in the document's ledger (`leads.enabled@<time>`, the database's clock when the process began, before the migrations), so a repository a new deployment registers while it waits, or between two starts, is never taken for its past. While the variable is not set, such a deployment gets that value written into the document under a comment saying why (`settings_default_kept`, once); a new one does not, and a value an operator has written stands. If that check fails (the database busy at the start), its key reads its default, `settings_bootstrap_check_failed` is logged at error level, and the check is asked again in the same run, after a minute and then at doubling intervals up to fifteen minutes, until it answers (`settings_bootstrap_check_settled`); a restart in between asks at its start, about the same moment. An import that fails outright is tried again in the same run the same way. A part of a variable the section drops, such as an unknown finder name in `LEADS_FINDERS`, is named in a `settings_env_value_dropped` warning. A value the section refuses is skipped with a `settings_bootstrap_value_refused` warning: set it in the document instead. A value refused only together with the section's other stored values is held (`settings_bootstrap_value_held`) and tried again at the next start. After that the variable is ignored: startup logs `settings_env_ignored` and `embry0 config` says the document governs it. The variable is removed one release later. The reference below names the variable each key was imported from.
 - **After a rollback.** A section or a key that a newer release wrote and this one does not know is kept as long as it is sent back exactly as stored (as the stored text has it, or as GET's `data` does), and is listed in `unknown_sections` or `unknown_keys`.
-- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). And `slop_meter.bots` and `slop_meter.ai_agents` are lists each document adds to: a layer's items join those it inherits, each once without regard to case, and no layer takes one out (the reference marks them *added to*; `entries` names the document each item comes from). A write of a key merged or added to is counted with what it inherits: one that would hold more entries than the key may is a 422 naming the count. A layer read when a document below has grown past that keeps every entry of its own and the inherited ones that fit, in their order (`settings_layer_entries_left_out`). A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
+- **Layers by organization and repository** ([ADR 0028](adr/0028-settings-layers.md)). An organization and a repository can each have a layer: a document of the same shape that holds only what it sets, read and written with `?owner=acme` or `?repo=acme/widgets` on the same routes, recorded and undone the same way. A key takes the value of the most specific layer that sets it (the deployment's document, then the organization's layer, then the repository's), and a layer replaces an inherited value whole. The exceptions are `leads.ask_severities`, merged kind by kind, and `slop_meter.weights`, merged glob by glob: the deployment's document over the default, and each layer over what it inherits. The entries a document names replace the entries below it; every other entry keeps them (the reference marks such a key *entry by entry*, and the effective view gives each entry's source in `entries`). And `slop_meter.bots` and `slop_meter.ai_agents` are lists each document adds to: a layer's items join those it inherits, each once without regard to case, and no layer takes one out (the reference marks them *added to*; `entries` names the document each item comes from). A write of a key merged or added to is counted with what it inherits: one that would hold more entries than the key may is a 422 naming the count. A layer read when a document below has grown past that keeps the most specific entries: its own, then its organization's, then the deployment's, then the default's (`settings_layer_entries_left_out`). Such a layer can still be written; only a write that makes the total larger than it was is refused. A repository belongs to the organization named by the first segment of its slug, so a GitLab project in a subgroup belongs to its top group; work with no repository reads the deployment's values. Each section says which of its keys an organization or a repository may set (the "Overridable by" column below); setting any other is a 422 naming the key. A value refused together with what it inherits is a 422 when written; if a later change below it makes it so, it is read as the inherited value, a `settings_layer_value_refused` warning is logged once per snapshot that reads it, and the write that caused it lists it in `layers_refused`. A repository renamed with `REPO_RENAMES` still reads the layer written under its old slug, and the first change made through `?repo=` with the new slug moves the layer to it, with its history, so the rename entry can later be removed. `GET /api/v1/config/settings/effective?repo=acme/widgets` shows what that repository reads, each key with the layer it came from and the value it overrides. Writing a layer takes an admin, with a key without a repository allowlist for an organization's layer, or one whose allowlist covers the repository for a repository's. The organization or repository must be registered. A key with a repository allowlist reads a repository's layer only when its list covers the repository, and an organization's only when it covers every repository registered under the owner; any other answers as a layer of an organization or repository nobody registered (404), is left out of `layers`, and has no revisions ([API keys](api.md#repository-allowlist)).
 - **Moved so far**, one section per bullet, in name order:
   - The asks policy (`asks`, from `ASKS_ENABLED` and the `ASK_*` variables): the ask loop reads it every tick and `GET /api/v1/asks/due` on every request, so turning asks on or changing their hours needs no restart. It is read per organization: an ask follows the layer of the organization its decision's repository belongs to for `hours`, `weekdays`, `timezone`, `remind_hours`, `expire_days` and `max_open_per_person`, and the deployment's document for the rest, so a change to an organization's layer applies to its asks on the next tick. An ask about a decision with no repository follows the deployment's document. `max_open_per_person` counts per person within an organization: someone asked about two organizations' decisions may hold each one's number, and the asks about decisions with no repository count apart. `enabled`, `lease_minutes` and `tick_seconds` are the deployment's alone.
   - Which repositories the background features read (`background`, from `SCOUT_REPOS`, `SCOUT_EXCLUDE`, `SLOP_METER_REPOS` and `SLOP_METER_EXCLUDE`, and what the scout and the Slop-O-Meter read before, into the repositories' layers): one switch per feature, `leads`, `scout` and `slop_meter`, which an organization's layer and a repository's layer may each set. A repository is read when it is registered, active and its switch resolves to true; nothing else enrolls it, not a job run on it. The scout and the meter are off until enrolled, and leads read every repository someone answers for unless a layer takes it out. Each loop reads it every tick, so opting a repository out stops it on the next one, and the meter removes what it kept of it `background.prune_after_days` (a week) later unless it comes back first ([which repositories](#which-repositories-background-features-read)).
@@ -550,7 +550,7 @@ How the Slop-O-Meter weighs a changed line and a person's attention, where its l
 |---|---|---|---|---|---|---|
 | `enabled` | true or false | `true` |  |  | `SLOP_METER_INTERVAL_SECONDS` | The meter reads the repositories enrolled in background.slop_meter and scores them. false stops the reading and the scoring everywhere; what was kept of a repository that left the scope is still removed after background.prune_after_days. Was SLOP_METER_INTERVAL_SECONDS=0. The deployment's alone. |
 | `interval_hours` | number | `24.0` | ≥ 0.25, ≤ 8760 |  | `SLOP_METER_INTERVAL_SECONDS` | Hours between two runs over every enrolled repository: fetch, read the next part of its history and events, and rescore it once caught up. While a history is still being read the meter comes back sooner (SLOP_METER_CATCHUP_SECONDS). A change applies within five minutes. At least a quarter hour. Was SLOP_METER_INTERVAL_SECONDS. The deployment's alone. |
-| `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins: the deployment's value is the credential's budget. An organization's value only narrows its own repositories' share of it, never widens it, and never lowers another organization's on the same credential. Git fetches are not API calls. |
+| `api_calls_per_tick` | whole number | `200` | ≥ 0, ≤ 10000 | organization | `SLOP_METER_API_CALLS_PER_TICK` | Forge API calls one run may make with one credential, shared round-robin by the repositories read with it, to read comments, reviews and logins: the deployment's value is the credential's budget. An organization's value only narrows its own repositories' share of it, never widens it, and never lowers another organization's on the same credential. A repository its share stops before its events are all read keeps its previous score, or stays unscored, until a run reads them all: a run reads from the first listing again. Git fetches are not API calls. |
 | `rate_reserve` | whole number | `2000` | ≥ 0, ≤ 100000 | organization | `SLOP_METER_RATE_RESERVE` | The rate limit a credential keeps for the jobs that use it: once its remaining calls (X-RateLimit-Remaining) drop below this, the run makes no further call with it. An organization's larger value stops only its own repositories' reads sooner; a smaller one changes nothing. |
 | `weights` | mapping | `{"*.py": 1.0, "*.pyi": 1.0, "*.ts": 1.0, "*.mts": 1.0, "*.cts": 1.0, "*.js": 1.0, "*.mjs": 1.0, "*.cjs": 1.0, "*.go": 1.0, "*.rs": 1.0, "*.java": 1.0, "*.kt": 1.0, "*.kts": 1.0, "*.scala": 1.0, "*.c": 1.0, "*.h": 1.0, "*.cc": 1.0, "*.cpp": 1.0, "*.cxx": 1.0, "*.hpp": 1.0, "*.hh": 1.0, "*.cs": 1.0, "*.rb": 1.0, "*.php": 1.0, "*.swift": 1.0, "*.m": 1.0, "*.mm": 1.0, "*.ex": 1.0, "*.exs": 1.0, "*.erl": 1.0, "*.clj": 1.0, "*.cljs": 1.0, "*.hs": 1.0, "*.ml": 1.0, "*.fs": 1.0, "*.lua": 1.0, "*.pl": 1.0, "*.pm": 1.0, "*.r": 1.0, "*.jl": 1.0, "*.dart": 1.0, "*.zig": 1.0, "*.nim": 1.0, "*.groovy": 1.0, "*.sh": 1.0, "*.bash": 1.0, "*.zsh": 1.0, "*.ps1": 1.0, "*.tf": 1.0, "*.sol": 1.0, "*.proto": 1.0, "*.graphql": 1.0, "*.gql": 1.0, "*.sql": 0.8, "*.tsx": 0.5, "*.jsx": 0.5, "*.vue": 0.5, "*.svelte": 0.5, "*.astro": 0.5, "*.html": 0.5, "*.htm": 0.5, "*.erb": 0.5, "*.hbs": 0.5, "*.ejs": 0.5, "*.jinja": 0.5, "*.j2": 0.5, "*.twig": 0.5, "*.liquid": 0.5, "*.css": 0.3, "*.scss": 0.3, "*.sass": 0.3, "*.less": 0.3, "*.styl": 0.3, "*.pcss": 0.3, "*.min.js": 0.0, "*.min.css": 0.0, "*.bundle.js": 0.0, "*.map": 0.0, "*.d.ts": 0.0}` |  | organization, entry by entry, repository, entry by entry |  | What one changed line of a file weighs, by glob, from 0 to 10; a file no glob matches weighs 0, so data, documents and binaries never count. A glob with no '/' matches a file's name in any directory (*.py), one with a '/' its path from the repository's root (db/migrations/*.sql, generated/**); '*' matches within one name, '?' one character, '**' any directories. Where several match, the most specific wins: a glob with a '/' over any without one; between two with one, more segments free of wildcards, then fewer ** segments, then fewer other segments with a wildcard, then more segments, then more literal characters; between two without, more literal characters (*.min.js over *.js); then the first in alphabetical order. So generated/** weighs every file under generated/, whatever its kind, and src/main.py wins over src/**/main.py. At most 16 globs that name no literal directory, no extension and no three literal characters in a row (*/*, *x*). Write globs in lowercase, quoted: matching ignores case, and YAML reads a bare * as an alias. Merged entry by entry: a document adds or changes the globs it names and keeps every other, so a glob set to 0 stops counting; at most 1000 globs in all, counted with the defaults and what a write inherits. |
 | `excluded_dirs` | list of text | `["vendor", "node_modules", "third_party", "third-party", "external", "deps", "bower_components"]` | at most 100 entries, each at most 100 characters | organization, repository |  | Directories whose files weigh nothing, each one name matched at any depth: vendored and third-party code. A list replaces the one it inherits whole; [] excludes none. |
diff --git a/docs/examples/settings.yaml b/docs/examples/settings.yaml
index d1a95008..c06295cc 100644
--- a/docs/examples/settings.yaml
+++ b/docs/examples/settings.yaml
@@ -419,8 +419,10 @@ slop_meter:
   # by the repositories read with it, to read comments, reviews and logins:
   # the deployment's value is the credential's budget. An organization's value
   # only narrows its own repositories' share of it, never widens it, and never
-  # lowers another organization's on the same credential. Git fetches are not
-  # API calls.
+  # lowers another organization's on the same credential. A repository its
+  # share stops before its events are all read keeps its previous score, or
+  # stays unscored, until a run reads them all: a run reads from the first
+  # listing again. Git fetches are not API calls.
   # api_calls_per_tick: 200
 
   # The rate limit a credential keeps for the jobs that use it: once its
diff --git a/docs/slop-meter.md b/docs/slop-meter.md
index 08d1f535..ddf214e2 100644
--- a/docs/slop-meter.md
+++ b/docs/slop-meter.md
@@ -95,16 +95,19 @@ The meter files each glob once and checks a path only against the globs that cou
 | with a `/` whose last segment has an extension (`*/*.py`) | names with that extension |
 | with a `/` and three literal characters in a row (`**/*_gen*`) | paths holding them |
 
-Any other glob (`*/*`, `*x*`) is checked against every path, so a write may hold at most 16 of them in `weights`, and 16 in `test_files`, counted with what it inherits.
+Any other glob (`*/*`, `*x*`) is checked against every path, so a write may hold at most 16 of them in `weights`, and 16 in `test_files`, counted with what it inherits. A write that leaves no more of them than readers read before is taken, so a layer a growing document below pushed over the bound can still change another key.
 
 **Layers.** An organization's layer may set every key but `enabled` and `interval_hours`, for its repositories: what counts as code, how fast its team attends to it, where its levels fall, its judge's guidance, its own bots and a narrower forge budget. A repository's layer may set what counts as code in its own layout: `weights`, `excluded_dirs`, `test_dirs`, `test_files` and `test_marks`.
 
 - `weights` is merged glob by glob, through every layer: a document adds or changes the globs it names and keeps every other, so a glob set to `0` stops counting.
 - `bots` and `ai_agents` add to what a layer inherits: a bot the deployment lists counts for every organization, and no layer takes one out. A bot spelled otherwise (`CI-Bot`, `ci-bot`) is the same bot, kept once.
-- **Counts.** A write is refused (422, naming the key and the count) when `weights`, `bots` or `ai_agents`, merged with what it inherits, would hold more than the key may (1000 globs, 200 bots, 200 agents). When a document below grows later, a layer read past the bound keeps every entry of its own, and the inherited ones that fit, in their order, with a warning (`settings_layer_entries_left_out`): never only the inherited list.
+- **Counts.** A write is refused (422, naming the key and the count) when `weights`, `bots` or `ai_agents`, merged with what it inherits, would hold more than the key may (1000 globs, 200 bots, 200 agents). When a document below grows later, a layer read past the bound keeps the most specific entries, with a warning (`settings_layer_entries_left_out`), never only the inherited list: every entry of its own, then its organization's, then the deployment's, then the default's, each in its order. So two repositories of one organization agree on the organization's globs. A layer left over the bound that way can still be written: only a write that makes the total larger than it was is refused, so it may change another key, or take entries out.
 - `excluded_dirs` and the `test_*` lists replace what they inherit whole, so a repository can take back a directory the default excludes (a `deps/` of its own code), restating the rest.
 - Every other key a layer sets replaces the inherited value.
-- **The forge budget.** A credential's budget is the deployment's `api_calls_per_tick` and `rate_reserve`. An organization's values only narrow its own repositories' share of it: fewer calls, or a larger reserve they stop at. They never widen it, and never lower what another organization reading with the same credential gets. A repository stopped only by its organization's share is scored with the events it read, and reads on from where it stopped at the next run; only the credential's own budget running out brings the meter back sooner (`SLOP_METER_CATCHUP_SECONDS`).
+- **The forge budget.** A credential's budget is the deployment's `api_calls_per_tick` and `rate_reserve`. An organization's values only narrow its own repositories' share of it: fewer calls, or a larger reserve they stop at. They never widen it, and never lower what another organization reading with the same credential gets. Only the credential's own budget running out brings the meter back sooner (`SLOP_METER_CATCHUP_SECONDS`).
+  - A repository stopped only by its organization's share keeps its previous score, or stays unscored, and waits for the next run. Its events are stored and its listings' cursors move, but each run starts reading at the first listing again.
+  - So a share too small for one whole read (on the order of the repository's listings: comments, review comments, pull requests, reviews) never reaches the reviews. A score from it would look complete, so none is written, and a settings change does not rescore it either.
+  - Keeping the reader's place between runs (#396) would let a small share finish over several runs.
 
 **Before this section.** `SLOP_METER_INTERVAL_SECONDS` (`0` turned the reading off), `SLOP_METER_API_CALLS_PER_TICK` and `SLOP_METER_RATE_RESERVE` are imported once, at the first start of the release that added the section, as `interval_hours` (or `enabled: false`), `api_calls_per_tick` and `rate_reserve`, and ignored after that. Each organization's `slop_meter_bots` was copied into its layer as `bots` ([api.md](api.md#organizations)). Everything else was a constant in the meter's code, and its default is that constant.
 
diff --git a/embry0/services/slop_meter/loop.py b/embry0/services/slop_meter/loop.py
index 21ce0ded..8ffab6d0 100644
--- a/embry0/services/slop_meter/loop.py
+++ b/embry0/services/slop_meter/loop.py
@@ -291,6 +291,9 @@ class _Work:
     #: Which credential reads it: a digest of its token, never the token. Each
     #: credential has its own rate limit, so each gets its own budget (#185).
     credential: str = ""
+    #: Its events were cut short by its organization's narrower share alone: not scored this run, and no
+    #: reason to come back sooner.
+    held: bool = False
 
 
 #: Reads what an organization's own settings still say of a moved key, until its layer has imported it
@@ -392,6 +395,9 @@ def __init__(
         self._backlog = False
         #: Whether the last look found the meter on; None before the first.
         self._enabled: bool | None = None
+        #: The repositories the last full run did not score because their organization's share cut their events
+        #: short: a rescore from what was read would score that short read, so they wait for a run that reads all.
+        self._held: set[str] = set()
         #: Each repository's configuration version as this process last scored it, or tried to: a look rescores a
         #: repository whose stored score has another version only once per version, so one whose rescoring fails
         #: is not tried again every look.
@@ -444,6 +450,17 @@ async def tick(self, read: MeterRead | None = None) -> bool:
             if work[repo].more:
                 backlog = True
                 continue
+            if work[repo].held:
+                self._held.add(repo)
+                logger.info(
+                    "slop_meter_score_held",
+                    repo=repo,
+                    reason="its organization's forge share ran out before its events were read",
+                    hint="its previous score stays; a larger api_calls_per_tick for the organization lets a run "
+                    "read them all",
+                )
+                continue
+            self._held.discard(repo)
             try:
                 await self._score(repo)
             except Exception as exc:  # noqa: BLE001
@@ -558,10 +575,14 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
         A repository stopped by its credential's own budget or reserve waits:
         it is scored once its events are read, and the loop comes back after
         ``catchup_seconds``, as before. One stopped only by its organization's
-        narrower share is scored with what it read and goes on from its
-        cursors at the next run, at the interval: an organization that reads
-        less never holds the meter, and every other organization's
-        repositories, on its catch-up cadence.
+        narrower share keeps its previous score, or stays unscored, since a
+        read cut short would look complete: its events are stored and its
+        listings' cursors move, but a run starts its reading over at the first
+        listing, so a share too small for one whole read never reaches the
+        reviews (#396 would keep the reader's place). It waits for the next
+        run, at the interval: an organization that reads less never holds the
+        meter, or every other organization's repositories, on its catch-up
+        cadence.
         """
         deployment = self._meter.deployment()
         readers: dict[str, EventReader] = {}
@@ -632,6 +653,8 @@ async def _read_forge(self, order: list[str], work: dict[str, _Work]) -> None:
                 await self._store.set_login(login, email)
             if repo in waiting:
                 work[repo].more = True
+            elif repo in narrowed:
+                work[repo].held = True
 
     async def _inputs(self, repo: str, settings: SlopMeterSettings) -> Inputs:
         bots = own_identities([*await self._bots(repo), *settings.bots])
@@ -744,6 +767,8 @@ async def rescore_changed(self, read: MeterRead | None = None) -> list[str]:
             state = await self._store.state(repo)
             if int(state.get("commits_read") or 0) < int(state.get("commits_total") or 0):
                 continue  # still reading its history: its catch-up scores it
+            if repo in self._held:
+                continue  # its events were cut short: a full run that reads them all scores it
             try:
                 await self._score(repo, judge=False)
                 rescored.append(repo)
diff --git a/embry0/settings/document.py b/embry0/settings/document.py
index 2c7bc67e..739ebcb0 100644
--- a/embry0/settings/document.py
+++ b/embry0/settings/document.py
@@ -26,7 +26,7 @@
 import structlog
 import yaml
 
-from embry0.settings.layers import merged, over_default
+from embry0.settings.layers import cap_of, merged, over_default
 from embry0.settings.registry import (
     DOCUMENT_KEYS,
     MANAGED_BY_FILE,
@@ -251,6 +251,22 @@ def _message(section: Section[Any], error: Mapping[str, Any]) -> str:
     return msg
 
 
+def _size(value: Any) -> int:
+    return len(value) if isinstance(value, list | tuple | dict) else 0
+
+
+def _read_before(
+    section: Section[Any], base: Mapping[str, Any], stored_own: Mapping[str, Any], spread: Iterable[str]
+) -> dict[str, Any]:
+    """Each key merged or added to as a reader read it before a write: the document's stored entries over what it
+    inherits, or what it inherits alone."""
+    out: dict[str, Any] = {}
+    for name in spread:
+        own = stored_own.get(name, {} if name in section.merged_keys else [])
+        out[name] = merged(section, base, {name: own}, fit=False)[name]
+    return out
+
+
 def _too_many(section: Section[Any], error: Mapping[str, Any], count: int | None) -> str:
     """A merged or added key that holds ``count`` entries, with what it inherits, more than it may."""
     ctx = error.get("ctx") or {}
@@ -259,7 +275,7 @@ def _too_many(section: Section[Any], error: Mapping[str, Any], count: int | None
         return _message(section, error)
     return (
         f"holds {actual} entries together with the ones it inherits (the default's and those of the documents "
-        f"above this one), more than the {most} it may hold"
+        f"below this one), more than the {most} it may hold"
     )
 
 
@@ -481,10 +497,20 @@ def check(
                 data[key] = clean
             continue
         base = mapping((inherited or {}).get(key)) if layer != "deployment" else {}
-        before = {**base, **{k: v for k, v in kept_section.items() if k in section.model.model_fields}}
+        stored_own = {k: v for k, v in kept_section.items() if k in section.model.model_fields}
+        spread = (section.merged_keys | section.added_keys) & set(section.model.model_fields)
+        # What a reader read before the write: a key merged or added to over what it inherits.
+        before = {**base, **stored_own, **_read_before(section, base, stored_own, spread)}
         # A key merged or added to is checked as its readers read it, over what it inherits, so a count the read
-        # could not hold is refused here, naming the key; what is stored is the document's own entries.
+        # could not hold is refused here, naming the key; what is stored is the document's own entries. A write
+        # that does not make an over-bound total larger than readers read before (a document below grew since,
+        # and this one writes another key) is taken as the read takes it, fitted.
         combined = merged(section, base, known, fit=False)
+        fitted = merged(section, base, known, fit=True)
+        for name in spread & set(known):
+            cap = cap_of(section, name)
+            if cap is not None and _size(combined[name]) > cap and _size(combined[name]) <= _size(before.get(name)):
+                combined[name] = fitted[name]
         try:
             model = section.validate(
                 {**base, **combined}, context=None if context is None else {**context, STORED: before}
@@ -492,8 +518,8 @@ def check(
         except SectionRefused as exc:
             for error in exc.errors:
                 loc = tuple(error.get("loc") or ())
-                spread = loc and str(loc[0]) in known and str(loc[0]) in section.merged_keys | section.added_keys
-                if spread and error.get("type") == "too_long":
+                counted = bool(loc) and str(loc[0]) in known and str(loc[0]) in spread
+                if counted and error.get("type") == "too_long":
                     entries = combined.get(str(loc[0]))
                     count = len(entries) if isinstance(entries, list | tuple | dict) else None
                     problems.append(Problem((key, *loc), "too_long", _too_many(section, error, count)))
diff --git a/embry0/settings/layers.py b/embry0/settings/layers.py
index be56f2fc..69151f1a 100644
--- a/embry0/settings/layers.py
+++ b/embry0/settings/layers.py
@@ -23,7 +23,7 @@
 from __future__ import annotations
 
 import json
-from collections.abc import Mapping, Sequence
+from collections.abc import Callable, Mapping, Sequence
 from dataclasses import dataclass, field
 from typing import Any, Protocol, runtime_checkable
 
@@ -126,13 +126,44 @@ def _trimmed(section: Section[Any], key: str, below: int, kept: int) -> None:
         key=key,
         inherited=below,
         kept=kept,
-        hint="the layer's own entries and the ones it inherits are more than the key holds: every entry of the "
-        "layer's own is kept, and the inherited ones that fit, in their order",
+        hint="the layer's own entries and the ones it inherits are more than the key holds: the most specific are "
+        "kept, the layer's own, then those of the documents below it, nearest first, then the default's",
     )
 
 
+def _name(entry: Any) -> Any:
+    """What two entries of a merged mapping are compared by: their name."""
+    return entry
+
+
+def _entries(value: Any, mapping_key: bool) -> list[Any]:
+    """The entries of a merged key's value (a mapping's names) or an added key's (a list's items); none for any
+    other value."""
+    if mapping_key:
+        return list(value) if isinstance(value, Mapping) else []
+    return list(value) if isinstance(value, list | tuple) else []
+
+
+def beyond_default(section: Section[Any], key: str, value: Any) -> Any:
+    """The part of the deployment's merged ``value`` of ``key`` that is its own: what it adds to the section's
+    default, or changes in it."""
+    default = section.defaults().model_dump(mode="json").get(key)
+    if isinstance(value, Mapping):
+        base = default if isinstance(default, Mapping) else {}
+        return {name: entry for name, entry in value.items() if name not in base or base[name] != entry}
+    if isinstance(value, list | tuple):
+        known = {_same(item) for item in default or ()}
+        return [item for item in value if _same(item) not in known]
+    return value
+
+
 def merged(
-    section: Section[Any], inherited: Mapping[str, Any], values: Mapping[str, Any], *, fit: bool = True
+    section: Section[Any],
+    inherited: Mapping[str, Any],
+    values: Mapping[str, Any],
+    *,
+    fit: bool = True,
+    tiers: Mapping[str, Sequence[Any]] | None = None,
 ) -> dict[str, Any]:
     """A document's ``values`` as they apply over ``inherited``.
 
@@ -144,71 +175,55 @@ def merged(
     it.
 
     ``fit`` is how a read takes a key that, so merged, holds more entries than
-    its ``max_length``, as when the document below it grew after the layer was
-    written: every entry the document names itself is kept, and the inherited
-    ones that fit, in their order, the rest left out with a warning
-    (``settings_layer_entries_left_out``). A write checks with ``fit`` false,
-    so the same count is refused there, naming the key.
+    its ``max_length``, as when a document below it grew after the layer was
+    written. The entries kept are the most specific first: every entry the
+    document names itself, then those of the documents below it, nearest
+    first, then the default's, each in its order, until the bound; the rest
+    are left out with a warning (``settings_layer_entries_left_out``).
+    ``tiers`` names, per key, the values of the documents below, nearest
+    first, ending with the default (:func:`resolve` knows them); without it,
+    the inherited value counts as one document. A write checks with ``fit``
+    false, so the same count is refused there, naming the key.
     """
     out = dict(values)
     defaults: dict[str, Any] | None = None
-    for key in section.added_keys & set(values):
+    for key in (section.merged_keys | section.added_keys) & set(values):
+        mapping_key = key in section.merged_keys
         own = values[key]
-        if not isinstance(own, list | tuple):
+        if not isinstance(own, Mapping if mapping_key else list | tuple):
             continue
         defaults = defaults if defaults is not None else section.defaults().model_dump(mode="json")
-        below: list[Any] = []
-        seen: set[Any] = set()
-        for layer in (defaults.get(key), inherited.get(key)):
-            if isinstance(layer, list | tuple):
-                for item in layer:
+        below = (defaults.get(key), inherited.get(key))
+        union: Any
+        if mapping_key:
+            union = {}
+            for layer in below:
+                if isinstance(layer, Mapping):
+                    union.update(layer)
+            union.update(own)
+        else:
+            union, seen = [], set()
+            for layer in (*below, own):
+                for item in _entries(layer, False):
                     if _same(item) not in seen:
                         seen.add(_same(item))
-                        below.append(item)
-        mine: list[Any] = []
-        named: set[Any] = set()
-        for item in own:
-            if _same(item) not in named:
-                named.add(_same(item))
-                mine.append(item)
-        items = below + [item for item in mine if _same(item) not in seen]
-        cap = cap_of(section, key)
-        if fit and cap is not None and len(items) > cap:
-            room = cap - len(mine)
-            trimmed: list[Any] = []
-            for item in below:
-                if _same(item) in named:
-                    trimmed.append(item)
-                elif room > 0:
-                    trimmed.append(item)
-                    room -= 1
-            trimmed.extend(item for item in mine if _same(item) not in seen)
-            _trimmed(section, key, len(below), len(trimmed))
-            items = trimmed
-        out[key] = items
-    for key in section.merged_keys & set(values):
-        own = values[key]
-        if not isinstance(own, Mapping):
-            continue
-        defaults = defaults if defaults is not None else section.defaults().model_dump(mode="json")
-        entries: dict[str, Any] = {}
-        for layer in (defaults.get(key), inherited.get(key)):
-            if isinstance(layer, Mapping):
-                entries.update(layer)
+                        union.append(item)
         cap = cap_of(section, key)
-        if fit and cap is not None and len({**entries, **own}) > cap:
-            room = cap - len(own)
-            kept: dict[str, Any] = {}
-            for name, value in entries.items():
-                if name in own:
-                    continue
-                if room <= 0:
-                    break
-                kept[name] = value
-                room -= 1
-            _trimmed(section, key, len(entries), len(kept) + len(own))
-            entries = kept
-        out[key] = {**entries, **own}
+        if fit and cap is not None and len(union) > cap:
+            identity: Callable[[Any], Any] = _name if mapping_key else _same
+            order = (own, *(tiers.get(key, ()) if tiers is not None else (inherited.get(key), defaults.get(key))))
+            keep: set[Any] = {identity(entry) for entry in _entries(own, mapping_key)}
+            for layer in order[1:]:
+                for entry in _entries(layer, mapping_key):
+                    if len(keep) >= cap:
+                        break
+                    keep.add(identity(entry))
+            _trimmed(section, key, len(union) - len(_entries(own, mapping_key)), len(keep))
+            if mapping_key:
+                union = {name: entry for name, entry in union.items() if name in keep}
+            else:
+                union = [item for item in union if _same(item) in keep]
+        out[key] = union
     return out
 
 
@@ -235,8 +250,15 @@ def resolve(
     current = dict(base)
     applied: dict[str, dict[str, Any]] = {}
     refused: list[LayerRefusal] = []
+    # Per key merged or added to, the documents below the next layer, nearest first, then the default: what a read
+    # past the key's bound keeps, the most specific first (:func:`merged`).
+    spread = (section.merged_keys | section.added_keys) & set(section.model.model_fields)
+    defaults = section.defaults().model_dump(mode="json") if spread else {}
+    tiers: dict[str, list[Any]] = {
+        key: [beyond_default(section, key, base.get(key)), defaults.get(key)] for key in spread
+    }
     for scope, values in layers:
-        accepted = merged(section, current, values)
+        accepted = merged(section, current, values, tiers=tiers)
         while accepted:
             try:
                 section.validate({**current, **accepted})
@@ -255,6 +277,8 @@ def resolve(
         if accepted:
             current = {**current, **accepted}
             applied[scope] = accepted
+            for key in spread & set(accepted):
+                tiers[key] = [values[key], *tiers[key]]
     if not applied and base_model is not None:
         return Resolved(base_model, {}, tuple(refused))
     try:
diff --git a/embry0/settings/registry.py b/embry0/settings/registry.py
index 389add51..eb0895f0 100644
--- a/embry0/settings/registry.py
+++ b/embry0/settings/registry.py
@@ -232,8 +232,10 @@ class Section[M: SectionModel]:
     field's default ones and a layer's after what it inherits, each item once
     (text without regard to case), so no layer takes an item out of the list
     below it. A write counts either kind with what it inherits against the
-    field's ``max_length``; a read past it keeps the document's own entries
-    and the inherited ones that fit (:func:`embry0.settings.layers.merged`).
+    field's ``max_length``, refusing only a write that makes an over-bound
+    total larger; a read past it keeps the most specific entries first: the
+    document's own, then those of the documents below it, nearest first,
+    then the default's (:func:`embry0.settings.layers.merged`).
     ``env`` maps a field to the ``Embry0Config`` attribute its value is
     imported from, once (``embry0.settings.bootstrap``): a string is the
     attribute, an :class:`EnvImport` adds a converter, the parts it drops, or a
diff --git a/embry0/settings/sections/slop_meter.py b/embry0/settings/sections/slop_meter.py
index 1b1b658a..4954ea31 100644
--- a/embry0/settings/sections/slop_meter.py
+++ b/embry0/settings/sections/slop_meter.py
@@ -57,7 +57,7 @@
 import hashlib
 import json
 import unicodedata
-from collections.abc import Iterable
+from collections.abc import Iterable, Mapping
 from typing import Annotated, Any, Final
 
 from pydantic import Field, StringConstraints, ValidationInfo, field_validator, model_validator
@@ -73,7 +73,7 @@
     check_glob,
     check_mark,
 )
-from embry0.settings.registry import EnvImport, Section, SectionModel, refuse_unprintable
+from embry0.settings.registry import STORED, EnvImport, Section, SectionModel, refuse_unprintable
 
 # ---- the defaults: the published algorithm's values, as the meter read them before this section ----
 
@@ -178,12 +178,18 @@ def _few_broad(globs: Iterable[str], info: ValidationInfo) -> None:
 
     Checked when a write is stored (it carries a validation context), with what
     the key inherits, never when a stored value is read: a document below that
-    grows later never makes a layer's globs read as refused.
+    grows later never makes a layer's globs read as refused. A write that leaves
+    no more broad globs than readers read before it (:data:`STORED`, merged with
+    what it inherits) is taken, so a layer over the bound because a document
+    below grew can still change its other keys, or take globs out.
     """
     if info.context is None:
         return
     count = sum(1 for glob in globs if broad(glob))
-    if count > MAX_BROAD_GLOBS:
+    stored = info.context.get(STORED) if isinstance(info.context, Mapping) else None
+    held = stored.get(info.field_name) if isinstance(stored, Mapping) and info.field_name else None
+    before = sum(1 for glob in held or () if broad(glob))
+    if count > MAX_BROAD_GLOBS and count > before:
         raise ValueError(
             f"{count} globs, with the ones inherited, name no literal directory, no extension and no "
             f"{GRAM} literal characters in a row (such as */* or *x*); at most {MAX_BROAD_GLOBS}, since each is "
@@ -240,7 +246,9 @@ class SlopMeterSettings(SectionModel):
             "Forge API calls one run may make with one credential, shared round-robin by the repositories read "
             "with it, to read comments, reviews and logins: the deployment's value is the credential's budget. "
             "An organization's value only narrows its own repositories' share of it, never widens it, and never "
-            "lowers another organization's on the same credential. Git fetches are not API calls."
+            "lowers another organization's on the same credential. A repository its share stops before its events "
+            "are all read keeps its previous score, or stays unscored, until a run reads them all: a run reads "
+            "from the first listing again. Git fetches are not API calls."
         ),
     )
     rate_reserve: int = Field(
diff --git a/tests/unit/services/slop_meter/test_loop_settings.py b/tests/unit/services/slop_meter/test_loop_settings.py
index f7fb59b0..3f7fe363 100644
--- a/tests/unit/services/slop_meter/test_loop_settings.py
+++ b/tests/unit/services/slop_meter/test_loop_settings.py
@@ -289,8 +289,8 @@ async def read_with(section: Section, found: dict[str, Any], tokens: Mapping[str
     "narrower", [{"api_calls_per_tick": 0}, {"api_calls_per_tick": 3}, {"rate_reserve": 100_000}], ids=str
 )
 async def test_an_organization_that_reads_less_never_holds_the_meter_on_catch_up(narrower: dict[str, int]) -> None:
-    """A repository stopped only by its organization's narrower share is scored with what it read and goes on at the
-    next run: six hours of looks at a 24-hour interval are one full run, one fetch of the other organization."""
+    """A repository stopped only by its organization's narrower share waits for the next run, at the interval: six
+    hours of looks at a 24-hour interval are one full run, and one fetch of the other organization."""
     acme, globex = "acme/app", "globex/app"
     records, order = fakes._history(2)
     forges = {name: fakes.FakeForge(comment_pages=1, repo=name) for name in (acme, globex)}
@@ -302,7 +302,50 @@ async def test_an_organization_that_reads_less_never_holds_the_meter_on_catch_up
         clock[0] += timedelta(minutes=5)
     assert runs.count("run") == 1, f"one full run in six hours, not one every catch-up: {runs.count('run')}"
     assert [repo for repo, _ in mirror.synced].count(globex) == 1, "globex is fetched once"
-    assert acme in store.stored and globex in store.stored, "and acme is scored with the events it read"
+    assert globex in store.stored, "and scored"
+
+
+def _narrowed(share: int, store: fakes.FakeStore | None = None) -> tuple[SlopMeterLoop, fakes.FakeStore, Any]:
+    acme, globex = "acme/app", "globex/app"
+    records, order = fakes._history(5)
+    forges = {name: fakes.FakeForge(comment_pages=1, repo=name) for name in (acme, globex)}
+    store = store if store is not None else fakes.FakeStore()
+    section = Section({}, acme={"api_calls_per_tick": share})
+    loop = _loop(section, store, fakes.FakeMirror(records, order), [NOW], repos=(acme, globex), forges=forges)
+    return loop, store, section
+
+
+@pytest.mark.parametrize("share", [1, 2, 3])
+async def test_a_share_too_small_for_a_whole_read_scores_nothing(share: int) -> None:
+    """A run starts reading at the first listing again, so a share that never reaches the reviews would score a
+    read that looks complete: the repository stays unscored, and never puts the meter on catch-up (#396 would
+    keep the reader's place)."""
+    loop, store, _ = _narrowed(share)
+    backlog = [await loop.tick() for _ in range(10)]
+    assert "acme/app" not in store.stored, f"{share} calls a run never read acme's reviews: no score is written"
+    assert "globex/app" in store.stored and not any(backlog), "the others are scored, at the interval"
+
+
+async def test_a_share_large_enough_for_a_whole_read_scores() -> None:
+    loop, store, _ = _narrowed(4)
+    for _ in range(10):
+        await loop.tick()
+    assert "acme/app" in store.stored, "four calls a run read every listing: acme is scored"
+    assert any(e["kind"] == "review" for e in store.event_rows["acme/app"].values()), "with its reviews"
+
+
+async def test_a_repository_whose_share_cuts_its_events_short_keeps_its_previous_score() -> None:
+    loop, store, section = _narrowed(200)
+    await loop.scheduled()
+    scored = store.stored["acme/app"]
+    section.owners["acme"] = {"api_calls_per_tick": 1}
+    loop._last_pass = None  # noqa: SLF001 - the next look is a full run
+    assert await loop.scheduled() == "run"
+    assert store.stored["acme/app"] is scored, "the run its share cut short wrote no score: the previous one stays"
+    section.owners["acme"] = {"api_calls_per_tick": 1, "weights": {"*.py": 2.0}}
+    loop._clock = lambda: NOW + timedelta(minutes=5)  # noqa: SLF001
+    assert await loop.scheduled() is None, "nor does a settings change rescore it from that short read"
+    assert store.stored["acme/app"] is scored
 
 
 async def test_the_credential_s_own_budget_still_holds_the_meter_on_catch_up() -> None:
diff --git a/tests/unit/settings/test_slop_meter_section.py b/tests/unit/settings/test_slop_meter_section.py
index 52f7c2a1..0f4c20ad 100644
--- a/tests/unit/settings/test_slop_meter_section.py
+++ b/tests/unit/settings/test_slop_meter_section.py
@@ -410,3 +410,66 @@ def test_a_layer_keeps_its_own_entries_when_the_document_below_grows_past_the_ca
     weights = widgets.model.weights
     assert len(weights) == 1000 and all(f"proj{i}/**" in weights for i in range(990)), "all of acme's own globs"
     assert widgets.model.lines_per_hour == 20, "and the rest of its layer"
+
+
+def test_a_read_past_the_bound_keeps_the_most_specific_layers_entries_first() -> None:
+    """The deployment grew to the bound after acme's layer and acme/app's were written: each repository keeps its
+    own globs, then acme's, then the deployment's, then the default's, so two repositories of acme agree on
+    acme's globs."""
+    from embry0.services.slop_meter.weights import FileRules
+    from embry0.settings.sections.slop_meter import SLOP_METER
+
+    defaults = len(_section().defaults().weights)
+    snapshot = _snapshot(
+        {
+            "deployment": {"weights": {f"dep{i}/**": 0.5 for i in range(1000 - defaults)}},
+            "organization:acme": {"weights": {f"org{i}/**": 0.0 for i in range(200)}},
+            f"repository:{WIDGETS}": {"weights": {f"repo{i}/**": 0.0 for i in range(100)}},
+        }
+    )
+    for repo in (WIDGETS, "acme/gizmos"):
+        weights = snapshot.resolve(SLOP_METER, repo=repo).model.weights
+        assert sum(name.startswith("org") for name in weights) == 200, f"{repo} keeps all of acme's globs"
+        assert FileRules.of(snapshot.resolve(SLOP_METER, repo=repo).model).weight("org199/x.py") == 0.0, repo
+    widgets = snapshot.resolve(SLOP_METER, repo=WIDGETS).model.weights
+    assert sum(name.startswith("repo") for name in widgets) == 100, "and acme/widgets its own"
+
+
+def _stored_layer(values: Mapping[str, Any], inherited: Mapping[str, Any], stored: Mapping[str, Any]) -> dict[str, str]:
+    """Each key an organization's layer storing ``stored`` and writing ``values`` over ``inherited`` is refused at."""
+    _section()
+    try:
+        check(
+            CATALOG,
+            {"slop_meter": dict(values)},
+            stored={"slop_meter": dict(stored)},
+            layer="organization",
+            inherited={"slop_meter": dict(inherited)},
+            context={},
+        )
+    except DocumentInvalid as exc:
+        return {".".join(str(part) for part in problem.loc[1:]): problem.msg for problem in exc.problems}
+    return {}
+
+
+def test_a_layer_over_the_bound_because_a_document_below_grew_can_still_write() -> None:
+    """Only a write that makes an over-bound total larger is refused: the layer's other keys, or fewer entries,
+    go through; one more entry does not."""
+    bots = {"bots": [f"org-bot-{i}" for i in range(60)]}
+    grown = {"bots": [f"dep-bot-{i}" for i in range(190)]}
+    assert _stored_layer({**bots, "lines_per_hour": 25}, grown, {**bots, "lines_per_hour": 20}) == {}, (
+        "an unrelated key"
+    )
+    assert _stored_layer({"bots": bots["bots"][:50]}, grown, bots) == {}, "fewer of its own"
+    more = _stored_layer({"bots": [*bots["bots"], "one-more"]}, grown, bots)
+    assert "holds 251 entries together with the ones it inherits (the default's and those of the documents below" in (
+        more.get("bots", "")
+    ), more
+    broad = {f"{letter}{i}*": 0.5 for letter in "qr" for i in range(10)}
+    org = dict(list(broad.items())[:10])
+    deployment = dict(list(broad.items())[10:])
+    assert _stored_layer({"weights": org, "lines_per_hour": 25}, {"weights": deployment}, {"weights": org}) == {}, (
+        "20 broad globs because the deployment added ten: acme may still change its pace"
+    )
+    refused = _stored_layer({"weights": {**org, "s1*": 0.5}}, {"weights": deployment}, {"weights": org})
+    assert "checked against every path" in refused.get("weights", ""), "but not add an eleventh of its own"