FabledCurator/backend/app/services/worker_control.py

"""Read and change a lane's live pool, over the broker.

Milestone 422 step 2. The half of the milestone that does something.

## No docker socket is involved, and that is the point

Milestone 365 put "acting on the state" out of scope because restarting a
dead worker needs a docker socket the web container deliberately does not
have. That is true of RESTARTING a container. It is not true of changing how
much work a RUNNING worker does: celery's remote control sends a message over
the broker and the worker resizes its own pool. Same Redis the app already
uses, no new privilege, no new surface.

    pool_grow / pool_shrink   how many slots a lane runs
    add_consumer / cancel_consumer   whether it consumes its queues at all

The operator ruled the socket out independently (2026-09-22: *"this feature
is a very invasive idea in my mind and I'd like to avoid it"*), and nothing
here raises the question.

## The setting is PER PROCESS, not per lane total

`pool_grow(n, destination=[...])` adds n slots to EACH destination it names.
While the stack still runs several containers per lane — the operator's
production `worker` is `replicas: 2` — a single delta applied to a lane's
total would be wrong for every replica.

So `slots` means what `CELERY_CONCURRENCY` means: the pool size of one
process. The reconcile below drives EACH replica to that number
independently, computing its own delta from that replica's current pool, so
replicas that have drifted apart (one restarted, one was grown) converge
rather than being moved in lockstep from a shared baseline.

After step 5 there is one process per lane and the distinction disappears.
It matters now, and getting it wrong now would be invisible — the totals
would simply be double what the UI claimed.

## Why reserved() is read alongside the queue depth

Celery PREFETCHES: a worker pulls more messages than it can run and holds
them in memory. Those have already left the Redis list, so `LLEN` — which is
what `/api/system/activity/queues` reports — can read 0 while thirty tasks
are waiting inside a worker. Any judgement about backlog that uses only LLEN
under-reports, which matters for the UI and is disqualifying for step 7's
autoscaler.
"""

from __future__ import annotations

import asyncio
import logging
from dataclasses import dataclass, field
from datetime import UTC, datetime

from sqlalchemy import func, select
from sqlalchemy.ext.asyncio import AsyncSession

from ..models import TaskRun, WorkerLane
from .worker_lanes import (
    LANES,
    LANES_BY_QUEUE_KEY,
    MIN_POOL_SLOTS,
    Lane,
    derived_ceiling,
)

log = logging.getLogger(__name__)

# celery control is a broker round trip on a request path, so it gets a
# deadline (rule 156) — the same reasoning and the same budget as
# service_roster's inspect. A broker that stopped answering must make this
# report "not present", which is true, rather than hang the page.
CONTROL_TIMEOUT_SECONDS = 2.0


# The WORST case of `inspect_lanes_sync`, for callers that need a deadline.
#
# One broadcast plus three targeted reads. The targeted three normally return
# as soon as the named nodes answer; each can still cost a full timeout if a
# node disappears mid-read, so the bound stays four.
CONTROL_ROUND_TRIPS = 4

# Slack for the `asyncio.to_thread` handoff. A budget equal to the work is a
# budget that fails under load — the roster carried exactly that bug into the
# operator's first consolidated deploy and logged a TimeoutError per refresh
# while the inspect calls underneath were working fine.
CONTROL_SLACK_SECONDS = 3.0

INSPECT_BUDGET_SECONDS = (
    CONTROL_TIMEOUT_SECONDS * CONTROL_ROUND_TRIPS + CONTROL_SLACK_SECONDS
)


@dataclass
class LaneLiveState:
    """What `celery inspect` says about one lane right now.

    `present=False` is NOT "zero slots" — it is "nothing answered". A lane
    whose worker is restarting, or whose broker is unreachable, must read as
    unknown rather than as stopped: an unswept absence is not a verdict
    (snippet #3969). The reconcile in step 3 skips an absent lane rather than
    correcting it, which is only safe because this distinction is kept.
    """

    present: bool = False
    replicas: int = 0
    active: int = 0
    reserved: int = 0
    hostnames: list[str] = field(default_factory=list)
    # The queues this lane is actually consuming right now, across replicas.
    # Distinct from the lane's CONFIGURED queues: `cancel_consumer` stops a
    # worker consuming one without changing what it was started with, which
    # is how `enabled=false` is implemented. The reconcile needs this to tell
    # "already disabled" from "needs disabling" — without it, it would re-send
    # add_consumer for every queue on every tick forever (lesson #4183).
    consuming: set[str] = field(default_factory=set)
    # Pool size PER HOSTNAME, not aggregated. The resize below computes each
    # replica's own delta from its own current pool, so replicas that have
    # drifted apart converge instead of being moved in lockstep from a shared
    # baseline — which is what an aggregate here would silently reintroduce.
    pools: dict[str, int] = field(default_factory=dict)

    @property
    def pool(self) -> int | None:
        """One number for the UI. `max` rather than a sum: `slots` means the
        pool size of ONE process (see the module docstring), so the largest
        replica is the honest answer to "what is this lane set to". None when
        no replica reported — unknown, never zero."""
        return max(self.pools.values()) if self.pools else None

    @property
    def capacity(self) -> int:
        """Total slots across replicas — how many tasks this lane can run at
        once. Distinct from `pool`, and the two must not be confused: `pool`
        is the DIAL (one process's size, what grow/shrink move), `capacity` is
        the CAPABILITY. Asking "is this lane saturated" compares `active`,
        which is summed across replicas, against this — against `pool` it
        would call two half-busy replicas of 4 saturated at 4 active."""
        return sum(self.pools.values())


def _lane_for_queues(queues: tuple[str, ...]) -> Lane | None:
    return LANES_BY_QUEUE_KEY.get(tuple(sorted(queues)))


def inspect_lanes_sync() -> dict[str, LaneLiveState]:
    """Live state per lane name. Sync — callers wrap in asyncio.to_thread.

    Never raises. Every lane is present in the result; ones nothing answered
    for carry `present=False`, so a caller cannot accidentally read a missing
    lane as an empty one by iterating only what came back.
    """
    out = {lane.name: LaneLiveState() for lane in LANES}
    try:
        from ..celery_app import celery as celery_app

        # ONE broadcast, then three TARGETED reads.
        #
        # A broadcast with no `destination` cannot know how many replies to
        # expect, so it waits out its whole timeout rather than returning on
        # the last one. Four of those is four full timeouts — about eight
        # seconds — and `lane_view` sits on the Settings card, so that was the
        # load time of the Worker lanes page every time it was opened.
        #
        # Naming the destinations lets celery stop as soon as those nodes have
        # answered, which for workers in this same container is milliseconds.
        # The worst case is unchanged: a node that vanishes between the
        # broadcast and the targeted reads costs a full timeout waiting for a
        # reply that is not coming.
        insp = celery_app.control.inspect(timeout=CONTROL_TIMEOUT_SECONDS)
        active_queues = insp.active_queues() or {}

        # Nothing answered — and the three reads below exist only to describe
        # what did. Returning here also makes the broker-down case FAST
        # (one timeout, not four), which is exactly when the healthcheck and
        # the card need an answer rather than a long wait.
        if not active_queues:
            return out

        targeted = celery_app.control.inspect(
            destination=sorted(active_queues),
            timeout=CONTROL_TIMEOUT_SECONDS,
        )
        stats = targeted.stats() or {}
        active = targeted.active() or {}
        reserved = targeted.reserved() or {}
    except Exception:
        log.warning("worker_control: celery inspect failed", exc_info=True)
        return out

    for hostname, queues in active_queues.items():
        lane = _lane_for_queues(tuple(q["name"] for q in queues))
        if lane is None:
            # A deployment slicing CELERY_QUEUES differently. Reported by the
            # roster under its raw queue list; it simply has no lane row to
            # control, which is honest rather than an error.
            continue
        state = out[lane.name]
        state.present = True
        state.replicas += 1
        state.hostnames.append(hostname)
        state.active += len(active.get(hostname, []))
        state.reserved += len(reserved.get(hostname, []))
        state.consuming.update(q["name"] for q in queues)

        # `pool.max-concurrency` is the number pool_grow/pool_shrink move and
        # the number the UI shows. Absent on a worker whose stats did not
        # answer, which leaves pool=None — unknown, not zero.
        pool = (stats.get(hostname) or {}).get("pool", {}).get("max-concurrency")
        if isinstance(pool, int):
            state.pools[hostname] = pool

    for state in out.values():
        state.hostnames.sort()
    return out


def effective_slots(target: int) -> int:
    """What a pool can actually be set to. Never below one process.

    Used wherever a target is COMPARED as well as wherever one is sent: a
    reconcile that compares against the unclamped number sees a difference
    that no control message can ever close, and re-sends it every tick.
    """
    return max(MIN_POOL_SLOTS, target)


def set_lane_slots_sync(
    lane: Lane, target: int, live: LaneLiveState | None = None,
) -> tuple[bool, str | None]:
    """Drive every replica of `lane` to `target` slots. Returns (applied, err).

    Per-replica deltas rather than one shared delta: see the module docstring.
    A replica already at the target is issued nothing at all, which is what
    makes step 3's periodic reconcile converge instead of re-sending a grow of
    zero forever (lesson #4183 — an enforcer without a reachable fixed point
    re-does its own work every tick).

    `applied=False` is not a failure of the SETTING. The caller has already
    stored the value; this says only that the live push did not land, and the
    reconcile will carry it when the lane answers again.
    """
    target = effective_slots(target)
    try:
        from ..celery_app import celery as celery_app

        if live is None:
            live = inspect_lanes_sync()[lane.name]
        if not live.present:
            return False, "lane is not running"
        if not live.pools:
            return False, "worker did not report its pool size"

        control = celery_app.control
        unreported = [h for h in live.hostnames if h not in live.pools]
        for hostname, current in live.pools.items():
            delta = target - current
            if delta > 0:
                control.pool_grow(delta, destination=[hostname])
            elif delta < 0:
                control.pool_shrink(-delta, destination=[hostname])
        if unreported:
            # Resized what could be resized, and said which could not. Silence
            # here would leave a replica running at a size the UI claims it is
            # not, with nothing anywhere recording the gap.
            return False, f"no pool size reported by {', '.join(sorted(unreported))}"
        return True, None
    except Exception as exc:  # noqa: BLE001 — reported, never raised at a caller
        log.warning("worker_control: could not resize %s", lane.name, exc_info=True)
        return False, str(exc)


def set_lane_enabled_sync(
    lane: Lane, enabled: bool, live: LaneLiveState | None = None,
) -> tuple[bool, str | None]:
    """Start or stop `lane` consuming its queues, without killing the process.

    `cancel_consumer` rather than a shutdown: a stopped consumer keeps its
    worker alive and answering `inspect`, so a disabled lane stays visible and
    can be turned back on. A killed worker would read as absent, which is the
    same signal as a crash — and the whole point of the roster (#365) is that
    those two must not look alike.
    """
    try:
        from ..celery_app import celery as celery_app

        if live is None:
            live = inspect_lanes_sync()[lane.name]
        if not live.present:
            return False, "lane is not running"
        control = celery_app.control
        for queue in lane.queues:
            if enabled:
                control.add_consumer(queue, destination=live.hostnames)
            else:
                control.cancel_consumer(queue, destination=live.hostnames)
        return True, None
    except Exception as exc:  # noqa: BLE001
        log.warning(
            "worker_control: could not %s %s",
            "enable" if enabled else "disable", lane.name, exc_info=True,
        )
        return False, str(exc)


# --- the settings half, which is async ----------------------------------------
#
# Sync celery control above, async DB below, in one module. Same split
# `service_roster` already runs (`_inspect_celery_sync` beside `touch_service`)
# — the boundary is the transport, not the concern, and "control the workers"
# is one concern.


async def _rows_by_name(session: AsyncSession) -> dict[str, WorkerLane]:
    """Every lane's row, creating any that are missing from its LANES defaults.

    Self-heals rather than depending on a migration having run for a lane
    added later: alembic 0103 seeded the four that existed on 2026-09-22, and
    a fifth added to LANES afterwards gets its row the first time anything
    asks. Without this, a new lane would read as absent and the UI would
    simply not show it.
    """
    rows = {
        row.name: row
        for row in (await session.execute(select(WorkerLane))).scalars()
    }
    missing = [lane for lane in LANES if lane.name not in rows]
    for lane in missing:
        row = WorkerLane(name=lane.name, slots_cap=lane.default_slots_cap)
        session.add(row)
        rows[lane.name] = row
    if missing:
        await session.commit()
    return rows


async def lane_view(session: AsyncSession) -> list[dict]:
    """Every lane: what is configured, what is live, what it may grow to.

    One call rather than making the UI join three sources. `pending` is the
    honest backlog — Redis depth PLUS reserved — because celery prefetches and
    LLEN alone reads 0 while a worker holds tasks in memory.
    """
    rows = await _rows_by_name(session)
    # A deadline, because this is a request path and `to_thread` on its own is
    # an await with no bound (rule 156). `inspect_lanes_sync` never raises and
    # every inner call has its own timeout, so the only way past the budget is
    # the thread not being scheduled — and a page that renders "not answering"
    # is a better answer than one that does not render.
    try:
        live = await asyncio.wait_for(
            asyncio.to_thread(inspect_lanes_sync),
            timeout=INSPECT_BUDGET_SECONDS,
        )
    except TimeoutError:
        log.warning(
            "worker_control: inspect exceeded %ss; reporting every lane as "
            "not answering", INSPECT_BUDGET_SECONDS,
        )
        live = {lane.name: LaneLiveState() for lane in LANES}
    depths = await asyncio.to_thread(_queue_depths_sync)
    oldest = await _oldest_running_by_queue(session)

    now = datetime.now(UTC)
    out = []
    for lane in LANES:
        row = rows[lane.name]
        state = live[lane.name]
        # None for a queue the broker did not answer for, which must not be
        # silently summed as zero — an unknown depth is not an empty one.
        known = [depths.get(q) for q in lane.queues]
        depth = sum(d for d in known if d is not None) if any(
            d is not None for d in known
        ) else None
        out.append({
            "name": lane.name,
            "display_name": lane.display_name,
            "queues": list(lane.queues),
            "slots_cap": row.slots_cap,
            "ceiling": derived_ceiling(lane),
            # DERIVED, never stored. A cap of zero means no consumers, so
            # "off" and "may use no workers" cannot disagree.
            "enabled": row.slots_cap > 0,
            "memory_bound": lane.memory_bound,
            "optional": lane.optional,
            # What raising this lane's cap will download, so the UI can say
            # WHICH model and how big BEFORE the first slot is asked for
            # rather than after a multi-GB fetch has started. `measured`
            # travels with the numbers: the UI must not present an estimate
            # as a fact.
            "models": [
                {
                    "repo": m.repo,
                    "download_bytes": m.approx_download_bytes,
                    "resident_bytes": m.approx_resident_bytes,
                    "measured": m.measured,
                }
                for m in lane.models
            ],
            "live": {
                "present": state.present,
                "replicas": state.replicas,
                "pool": state.pool,
                "active": state.active,
                "reserved": state.reserved,
            },
            "queue_depth": depth,
            "pending": None if depth is None else depth + state.reserved,
            # How long the oldest still-running task on this lane has been
            # going, in minutes. The operator asked for a trigger here — grow
            # a lane whose tasks run past some duration — and it stayed a
            # REPORT: a long task does not finish sooner because the lane
            # gained a slot, so scaling on it would spend memory to change
            # nothing. Shown so they can see a lane wedged on one slow job,
            # which is the genuinely useful half of the idea.
            "oldest_running_minutes": _minutes_since(
                min(
                    (oldest[q] for q in lane.queues if q in oldest),
                    default=None,
                ),
                now,
            ),
        })
    return out


async def _oldest_running_by_queue(session: AsyncSession) -> dict[str, datetime]:
    """When the longest-running unfinished task on each queue started.

    Read from `task_run`, which is OUR OWN table on OUR OWN wall clock, and
    deliberately not from celery's `inspect active()`. Those entries carry a
    `time_start` taken from the WORKER's `time.monotonic()` — a clock with an
    arbitrary origin per process. Subtracting it from this process's wall
    clock produces a number that looks like a duration and is meaningless, and
    it would be meaningless in the direction that matters: plausible.

    `task_run` also already carries the per-queue staleness thresholds the
    recovery sweep uses, so a row still `running` here is one the system
    itself considers legitimately in flight rather than abandoned.
    """
    result = await session.execute(
        select(TaskRun.queue, func.min(TaskRun.started_at))
        .where(TaskRun.status == "running", TaskRun.finished_at.is_(None))
        .group_by(TaskRun.queue)
    )
    return {queue: started for queue, started in result if started is not None}


def _minutes_since(started: datetime | None, now: datetime) -> int | None:
    """Whole minutes, or None when nothing is running. Never negative: a row
    written by a container whose clock is a few seconds ahead must read as 0
    rather than as a task that starts in the future."""
    if started is None:
        return None
    return max(0, int((now - started).total_seconds() // 60))


def _queue_depths_sync() -> dict[str, int | None]:
    """Redis LLEN per queue. None for one that did not answer — see lane_view.

    Sync; the caller threads it. A per-queue try/except so one bad queue does
    not cost the whole report, matching `api/system_activity._read_queues_sync`.
    """
    import redis

    from ..config import get_config

    out: dict[str, int | None] = {}
    try:
        client = redis.Redis.from_url(get_config().celery_broker_url)
    except Exception:
        log.warning("worker_control: no broker for queue depths", exc_info=True)
        return {q: None for lane in LANES for q in lane.queues}
    for lane in LANES:
        for queue in lane.queues:
            try:
                out[queue] = int(client.llen(queue))
            except Exception:  # noqa: BLE001 — a hiccup must not break the UI
                out[queue] = None
    return out


class LaneUpdateRefused(ValueError):
    """A requested value is outside what the lane may hold. Carries the reason
    the UI shows — a greyed control with no explanation reads as a bug."""


async def set_lane(session: AsyncSession, lane: Lane, *, slots_cap: int) -> dict:
    """Store the operator's cap for `lane`, then make the live lane obey it.

    ONE value, since 2026-09-23. It used to take `slots`, `slots_cap`,
    `enabled` and `autoscale`, which was four ways of saying two things — and
    two of them were the caller's job to keep in agreement with each other.

    ## What happens live, and what does not

    A cap CHANGE is pushed immediately in one direction only: lowering it
    shrinks the pool now, because a cap the operator just lowered should not
    be exceeded for up to a minute. Raising it does NOT grow the pool here —
    a cap is permission, not a request, and growing on permission would put
    slots on a lane with nothing to do. The sizing pass adds them on its next
    tick if there is work, which is the whole point of it being always on.

    Consumers follow the cap in both directions and immediately: zero means
    off, and off must take effect when it is asked for.

    A failed PUSH is not a failed setting. The value is saved either way and
    the sizing pass carries it within a minute; the result says `applied:
    false` with a reason so the UI can say "saved, not yet live" rather than
    "that didn't work" (lesson #4202 — a live change that does not survive,
    with nothing saying so).
    """
    rows = await _rows_by_name(session)
    row = rows[lane.name]

    ceiling = derived_ceiling(lane)
    if slots_cap < 0:
        raise LaneUpdateRefused("a cap cannot be negative")
    if slots_cap > ceiling:
        raise LaneUpdateRefused(
            f"a cap of {slots_cap} is above what this container can hold "
            f"({ceiling} for {lane.display_name})"
        )

    was_on = row.slots_cap > 0
    row.slots_cap = slots_cap
    await session.commit()

    now_on = slots_cap > 0
    applied, error = True, None
    if now_on != was_on:
        applied, error = await asyncio.to_thread(set_lane_enabled_sync, lane, now_on)
    if applied and not now_on:
        # Down to the floor at once. The pool cannot be emptied, so "off" is
        # one parked process with its consumers cancelled.
        applied, error = await asyncio.to_thread(
            set_lane_slots_sync, lane, MIN_POOL_SLOTS,
        )
    elif applied and now_on:
        # Only DOWNWARD. See the docstring: raising a cap is permission, and
        # the sizing pass decides whether there is work to spend it on.
        live = await asyncio.to_thread(inspect_lanes_sync)
        current = live[lane.name].pool
        if current is not None and current > slots_cap:
            applied, error = await asyncio.to_thread(
                set_lane_slots_sync, lane, slots_cap, live=live[lane.name],
            )

    # Raising the cap off zero is what triggers the model download (milestone
    # 422 step 6). Never at boot: that made every start of the ML role reach
    # HuggingFace for ~3.5GB, and rule 164 permits a runtime fetch only for a
    # feature that is optional and clearly OFF.
    #
    # On the TRANSITION, so re-saving a cap on a lane already running does not
    # re-enqueue. And only when the consumer change landed: enqueueing onto a
    # queue nothing is consuming would leave the task pending with no
    # explanation until the lane returns.
    fetching = False
    if now_on and not was_on and lane.models and applied:
        fetching = _enqueue_model_fetch()

    return {
        "name": lane.name,
        "slots_cap": row.slots_cap,
        "ceiling": ceiling,
        "enabled": now_on,
        "applied": applied,
        "apply_error": error,
        # Tells the UI to say a download has started rather than leaving the
        # operator to wonder why a lane they just turned on is busy.
        "fetching_models": fetching,
    }


def _enqueue_model_fetch() -> bool:
    """Queue the model download. Returns whether it was accepted.

    Import inside the function: `backend.app.tasks.ml` pulls in torch, and web
    must not pay that import cost on a module that every settings request
    touches.

    Never raises. A broker that will not take the task is worth reporting, but
    the SETTING has already been stored and the lane is already enabled — so
    failing the whole request here would roll back nothing and tell the
    operator their change did not happen when it did.
    """
    try:
        from ..tasks.ml import ensure_models

        ensure_models.delay()
        return True
    except Exception:  # noqa: BLE001 — reported, never raised at a caller
        log.warning("worker_control: could not enqueue the model fetch", exc_info=True)
        return False



# --- the sizing pass: one sweep, always on ------------------------------------
#
# This replaced BOTH `reconcile_lanes_sync` (step 3) and `autoscale_lanes_sync`
# (step 7) on 2026-09-23. They were two enforcers over one number, and the
# whole of step 7's hardest reasoning — a stored value that is a FLOOR, a
# target of `max(stored, current)` so the reconcile does not undo what the
# autoscaler added — existed only to stop them fighting. Delete one of them and
# the problem is not solved, it is absent.
#
# Operator: *"auto should be always on, not a setting, so that idle instances
# quiet down when not running. the number that is visible and something the
# user can tweak and manage should be the cap itself the number of running
# workers is handled by the autoscaling function which is always on."*
#
# So there is one pass, it runs every minute, it reads the live pool rather
# than any stored number, and the only thing it obeys is the cap.
#
# It also subsumes what the reconcile existed for. `pool_grow` is not durable:
# a worker restarted by its supervisor comes back at its ENV concurrency,
# silently below what the lane should be running. This pass reads the live
# pool every minute and sizes from the backlog, so that worker is corrected on
# the next tick — sooner than the five-minute reconcile managed, and without a
# second sweep that could disagree with this one.

# How much work justifies a slot. `pending` is depth + reserved, so it already
# counts what celery has prefetched into worker memory — one task, one slot.
#
# Growth is IMMEDIATE and shrink is one slot per tick, deliberately asymmetric.
# A backlog of four thousand should not take an hour to reach the cap, and a
# lane that idles for one minute should not drop every process it has: the
# cost of being one slot too large for a minute is a sleeping process, and the
# cost of being too small is work not happening. For ML the asymmetry matters
# most — every new slot reloads a multi-GB model, so the slow shrink is what
# stops a quiet patch from paying that cost again a minute later.
SHRINK_STEP = 1


@dataclass
class LaneSizing:
    """What the pass did to one lane, and why — in the operator's terms.

    A reason on every outcome including "held", because a sizing pass that
    only speaks when it acts is one nobody can debug when it does not.
    """

    lane: str
    action: str  # "grew" | "shrank" | "held" | "skipped"
    slots: int
    reason: str


def wanted_slots(cap: int, active: int, pending: int | None) -> int:
    """How many workers this lane has work for right now, within its cap.

    One slot per task in flight or waiting, floored at one process and
    ceilinged by the cap. `pending` of None means the broker did not answer
    for this lane's queues — an unknown backlog is not an empty one (snippet
    #3969), so it contributes nothing rather than being read as zero.

    A cap of zero still returns one: billiard cannot run an empty pool, and
    the parked process is what `add_consumer` lands on when the cap goes back
    up. "Off" is expressed by cancelling consumers, not by emptying the pool.
    """
    if cap <= 0:
        return MIN_POOL_SLOTS
    return max(MIN_POOL_SLOTS, min(cap, active + (pending or 0)))


def size_lanes_sync(caps: dict[str, int]) -> list[LaneSizing]:
    """Size every lane to its backlog, within the cap. The whole control loop.

    `caps` is lane name -> slots_cap, read from the database by the caller.
    This function touches no database: the celery task that schedules it owns
    the session, and keeping the DB out of here is what lets it be called from
    anywhere that already knows the caps.

    ## It must converge and then go quiet

    One `inspect` for all lanes, and `set_lane_slots_sync` issues nothing to a
    replica already at its target. A settled system therefore performs one
    broker round trip plus one LLEN sweep per tick and sends no control
    messages at all — the reachable fixed point lesson #4183 is about. An
    enforcer that re-sent a grow of zero every tick would churn forever and
    bury a real correction in its own noise.

    ## An absent lane is SKIPPED, not corrected

    `present=False` means nothing answered — a worker restarting, or an
    unreachable broker. It does NOT mean zero slots. Deciding from that would
    be a verdict drawn from an unswept read, and here it is worse than
    useless: there is nothing to send the message to.
    """
    live = inspect_lanes_sync()
    depths = _queue_depths_sync()
    out: list[LaneSizing] = []

    for lane in LANES:
        cap = caps.get(lane.name)
        if cap is None:
            continue
        state = live[lane.name]
        if not state.present:
            out.append(LaneSizing(lane.name, "skipped", 0, "lane is not answering"))
            continue

        # Consumers first, and only when they DISAGREE. Sending add_consumer
        # for every queue on every tick of a settled system is the exact churn
        # above, and invisible: add_consumer on a queue already consumed is
        # harmless and reports success.
        should_consume = cap > 0
        if should_consume != state.consuming.issuperset(lane.queues):
            ok, err = set_lane_enabled_sync(lane, should_consume, live=state)
            if not ok:
                out.append(LaneSizing(
                    lane.name, "held", state.pool or 0,
                    f"could not {'start' if should_consume else 'stop'} "
                    f"consuming: {err}",
                ))
                continue

        current = state.pool
        if current is None:
            out.append(LaneSizing(
                lane.name, "held", 0, "worker did not report its pool size",
            ))
            continue

        known = [depths.get(q) for q in lane.queues]
        depth = (
            sum(d for d in known if d is not None)
            if any(d is not None for d in known) else None
        )
        pending = None if depth is None else depth + state.reserved
        want = wanted_slots(cap, state.active, pending)

        if want > current:
            new = want
            verb = "grew"
        elif want < current:
            # One at a time on the way down. See SHRINK_STEP.
            new = max(want, current - SHRINK_STEP)
            verb = "shrank"
        else:
            out.append(LaneSizing(
                lane.name, "held", current,
                f"{pending if pending is not None else '?'} waiting, "
                f"{state.active} busy, cap {cap}",
            ))
            continue

        ok, err = set_lane_slots_sync(lane, new, live=state)
        if not ok:
            out.append(LaneSizing(
                lane.name, "held", current, f"could not resize: {err}",
            ))
            continue
        out.append(LaneSizing(
            lane.name, verb, new,
            f"{pending if pending is not None else '?'} waiting, "
            f"{state.active} busy, cap {cap}",
        ))
    return out