imbi-api 2.11.2__tar.gz → 2.11.4__tar.gz

{imbi_api-2.11.2 → imbi_api-2.11.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: imbi-api
-Version: 2.11.2
+Version: 2.11.4
 Summary: Imbi is a DevOps Service Management Platform designed to provide an efficient way to manage a large environment that contains many services and applications.
 Author-email: Alex Campbell <alexc@aweber.com>, Dave Shawley <daves@aweber.com>, "Gavin M. Roy" <gavinr@aweber.com>
 License: BSD-3-Clause
@@ -20,7 +20,7 @@ Requires-Dist: cyclonedx-python-lib<12,>=11.7
 Requires-Dist: fastapi
 Requires-Dist: filetype
 Requires-Dist: httpx<1,>=0.28.1
-Requires-Dist: imbi-common[databases,llm,sentry,server]==2.11.2
+Requires-Dist: imbi-common[databases,llm,sentry,server]==2.11.4
 Requires-Dist: jinja2
 Requires-Dist: jsonpatch>=1.33
 Requires-Dist: mcp>=1.26.0

{imbi_api-2.11.2 → imbi_api-2.11.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "imbi-api"
-version = "2.11.2"
+version = "2.11.4"
 description = "Imbi is a DevOps Service Management Platform designed to provide an efficient way to manage a large environment that contains many services and applications."
 readme = "README.md"
 requires-python = ">=3.14"
@@ -28,7 +28,7 @@ dependencies = [
   "fastapi",
   "filetype",
   "httpx>=0.28.1,<1",
-  "imbi-common[databases,llm,sentry,server]==2.11.2",
+  "imbi-common[databases,llm,sentry,server]==2.11.4",
   "jinja2",
   "jsonpatch>=1.33",
   "mcp>=1.26.0",

{imbi_api-2.11.2 → imbi_api-2.11.4}/src/imbi_api/app.py

@@ -26,6 +26,7 @@ def create_app() -> fastapi.FastAPI:
             valkey.valkey_lifespan,
             lifespans.score_worker_hook,
             lifespans.commit_sync_worker_hook,
+            lifespans.pr_sync_worker_hook,
             lifespans.identity_refresh_hook,
         ),
         version=version,

imbi_api-2.11.4/src/imbi_api/blueprint_compliance.py

@@ -0,0 +1,393 @@
+"""Blueprint property compliance check for Project Doctor.
+
+Compares a project's current AGE node properties against every
+applicable Project blueprint's JSON Schema and emits an
+:class:`~imbi_common.plugins.base.AnalysisResultItem` for each
+non-conformant property.
+
+This is a *built-in* check — no external plugin or credentials are
+required; it queries the graph directly.  The caller is responsible
+for wrapping the returned items into :class:`AnalysisResult` objects
+(adding ``plugin_slug`` and ``plugin_id``).
+"""
+
+from __future__ import annotations
+
+import logging
+import re
+import typing
+
+from imbi_common import graph, models
+from imbi_common.plugins.base import AnalysisResultItem
+
+from imbi_api.blueprint_attributes import project_blueprints
+
+LOGGER = logging.getLogger(__name__)
+
+BLUEPRINT_PLUGIN_SLUG = 'blueprint-compliance'
+BLUEPRINT_PLUGIN_ID = 'built-in'
+
+_SENTINEL = object()  # distinguishes "not present" from explicit None
+
+# Blueprint property names must be safe to embed in Cypher SET clauses.
+# Only allow names that look like identifiers.
+_SAFE_PROP_RE = re.compile(r'^[A-Za-z_][A-Za-z0-9_]*$')
+
+_FETCH_PROPS_QUERY = """
+MATCH (p:Project {{id: {project_id}}})
+RETURN p{{.*}} AS props
+"""
+
+
+async def _fetch_project_props(
+    db: graph.Graph, project_id: str
+) -> dict[str, typing.Any]:
+    rows = await db.execute(
+        _FETCH_PROPS_QUERY, {'project_id': project_id}, ['props']
+    )
+    if not rows:
+        return {}
+    raw = graph.parse_agtype(rows[0]['props'])
+    if not isinstance(raw, dict):
+        return {}
+    return typing.cast('dict[str, typing.Any]', raw)
+
+
+def _is_missing(value: typing.Any) -> bool:
+    return value is _SENTINEL or value is None or value == ''
+
+
+def _check_property(
+    section_slug: str,
+    prop_name: str,
+    prop_schema: models.Schema,
+    required: bool,
+    current_value: typing.Any,
+) -> AnalysisResultItem | None:
+    """Return a finding for a non-conformant property, or ``None``."""
+    display = getattr(prop_schema, 'title', None) or prop_name
+    missing = _is_missing(current_value)
+
+    if required and missing:
+        return AnalysisResultItem(
+            slug=f'{BLUEPRINT_PLUGIN_SLUG}:{section_slug}:{prop_name}:missing',
+            title=f'Required property not set: {display}',
+            description=(
+                f'`{prop_name}` is required by the **{section_slug}** '
+                f'blueprint but has no value. Edit the project to set it.'
+            ),
+            status='fail',
+        )
+
+    if not missing:
+        enum = getattr(prop_schema, 'enum', None)
+        if enum is not None and current_value not in enum:
+            choices = ', '.join(f'`{v}`' for v in enum)
+            return AnalysisResultItem(
+                slug=f'{BLUEPRINT_PLUGIN_SLUG}:{section_slug}:{prop_name}:invalid-enum',
+                title=f'Property value not in allowed set: {display}',
+                description=(
+                    f'`{prop_name}` is `{current_value!r}` but the '
+                    f'allowed values are: {choices}. '
+                    f'Edit the project to correct it.'
+                ),
+                status='fail',
+            )
+
+        minimum = getattr(prop_schema, 'minimum', None)
+        maximum = getattr(prop_schema, 'maximum', None)
+        if isinstance(current_value, (int, float)):
+            if minimum is not None and current_value < minimum:
+                return AnalysisResultItem(
+                    slug=f'{BLUEPRINT_PLUGIN_SLUG}:{section_slug}:{prop_name}:below-minimum',
+                    title=f'Property below minimum: {display}',
+                    description=(
+                        f'`{prop_name}` is `{current_value}` but '
+                        f'the minimum is `{minimum}`.'
+                    ),
+                    status='warn',
+                )
+            if maximum is not None and current_value > maximum:
+                return AnalysisResultItem(
+                    slug=f'{BLUEPRINT_PLUGIN_SLUG}:{section_slug}:{prop_name}:above-maximum',
+                    title=f'Property above maximum: {display}',
+                    description=(
+                        f'`{prop_name}` is `{current_value}` but '
+                        f'the maximum is `{maximum}`.'
+                    ),
+                    status='warn',
+                )
+
+    # Missing but not required — warn when a default is available
+    if missing:
+        default = getattr(prop_schema, 'default', None)
+        if default is not None:
+            return AnalysisResultItem(
+                slug=f'{BLUEPRINT_PLUGIN_SLUG}:{section_slug}:{prop_name}:use-default',
+                title=f'Property not set — default available: {display}',
+                description=(
+                    f'`{prop_name}` has no value. '
+                    f'The blueprint default is `{default!r}`. '
+                    f'Use **Apply Blueprint Fixes** to set it.'
+                ),
+                status='warn',
+            )
+
+    return None
+
+
+def _stale_blueprint_properties(
+    all_blueprints: list[models.Blueprint],
+    applicable: list[models.Blueprint],
+    current_props: dict[str, typing.Any],
+) -> list[str]:
+    """Return property names set on the project with no applicable blueprint.
+
+    A property is "stale" when it was set by a blueprint that no longer
+    applies to this project's type(s). Only considers properties defined in
+    *some* blueprint (so core model fields like ``id`` or ``name`` are never
+    flagged).
+    """
+    all_bp_props: set[str] = set()
+    for bp in all_blueprints:
+        if bp.kind != 'node':
+            continue
+        for prop_name in bp.json_schema.properties or {}:
+            all_bp_props.add(prop_name)
+
+    applicable_props: set[str] = set()
+    for bp in applicable:
+        for prop_name in bp.json_schema.properties or {}:
+            applicable_props.add(prop_name)
+
+    stale = all_bp_props - applicable_props
+    return [
+        p for p in stale if not _is_missing(current_props.get(p, _SENTINEL))
+    ]
+
+
+def _applicable_blueprints(
+    blueprints: list[models.Blueprint],
+    type_slug_set: set[str],
+) -> list[models.Blueprint]:
+    out: list[models.Blueprint] = []
+    for bp in blueprints:
+        if bp.kind != 'node':
+            continue
+        f = bp.filter
+        if (
+            f is not None
+            and f.project_type
+            and not type_slug_set.intersection(f.project_type)
+        ):
+            continue
+        if bp.json_schema.properties:
+            out.append(bp)
+    return out
+
+
+async def check_blueprint_compliance(
+    db: graph.Graph,
+    project_id: str,
+    type_slugs: list[str],
+) -> list[AnalysisResultItem]:
+    """Return blueprint compliance findings for a project.
+
+    Loads every enabled Project blueprint, filters to those that apply
+    to the project's types, and checks each property against the
+    project's current AGE node properties.  Returns a single ``pass``
+    item when everything is compliant so the Doctor card always shows
+    something for this check.
+    """
+    all_blueprints = await project_blueprints(db)
+    if not all_blueprints:
+        return [
+            AnalysisResultItem(
+                slug=f'{BLUEPRINT_PLUGIN_SLUG}:no-blueprints',
+                title='No Project blueprints configured',
+                description=(
+                    'No enabled Project blueprints are defined. '
+                    'Add blueprints to track property compliance.'
+                ),
+                status='pass',
+            )
+        ]
+
+    type_slug_set = set(type_slugs)
+    applicable = _applicable_blueprints(all_blueprints, type_slug_set)
+
+    props = await _fetch_project_props(db, project_id)
+    findings: list[AnalysisResultItem] = []
+
+    for bp in applicable:
+        schema = bp.json_schema
+        required_names: set[str] = set(schema.required or [])
+        section_slug = bp.slug or ''
+        for prop_name, prop_schema in (schema.properties or {}).items():
+            extra = prop_schema.model_extra or {}
+            x_ui = dict(extra.get('x-ui') or {})
+            required = (
+                prop_name in required_names or x_ui.get('required') is True
+            )
+            current_value = props.get(prop_name, _SENTINEL)
+            finding = _check_property(
+                section_slug, prop_name, prop_schema, required, current_value
+            )
+            if finding is not None:
+                findings.append(finding)
+
+    # Detect blueprint-managed properties no longer in any applicable
+    # blueprint.
+    stale = _stale_blueprint_properties(all_blueprints, applicable, props)
+    for prop_name in sorted(stale):
+        findings.append(
+            AnalysisResultItem(
+                slug=f'{BLUEPRINT_PLUGIN_SLUG}:stale:{prop_name}',
+                title=f'Property not in any applicable blueprint: {prop_name}',
+                description=(
+                    f'`{prop_name}` is set on this project but is not defined '
+                    f'in any currently applicable blueprint. '
+                    f'Use **Apply Blueprint Fixes** to remove it.'
+                ),
+                status='warn',
+            )
+        )
+
+    if not findings:
+        if not applicable:
+            return [
+                AnalysisResultItem(
+                    slug=f'{BLUEPRINT_PLUGIN_SLUG}:no-applicable',
+                    title='No blueprints apply to this project type',
+                    description=(
+                        "No enabled blueprints match this project's type(s)."
+                    ),
+                    status='pass',
+                )
+            ]
+        return [
+            AnalysisResultItem(
+                slug=f'{BLUEPRINT_PLUGIN_SLUG}:all-pass',
+                title='All blueprint properties are correctly set',
+                description=(
+                    'Every required and recommended blueprint property '
+                    'has a valid value.'
+                ),
+                status='pass',
+            )
+        ]
+    return findings
+
+
+async def apply_blueprint_defaults(
+    db: graph.Graph,
+    project_id: str,
+    type_slugs: list[str],
+) -> int:
+    """Set blueprint default values on project properties that are unset.
+
+    Only touches properties that are currently ``None`` / absent AND
+    have a ``default`` in the blueprint schema. Does not overwrite
+    existing values.
+
+    Returns the number of properties updated.
+    """
+    all_blueprints = await project_blueprints(db)
+    if not all_blueprints:
+        return 0
+
+    type_slug_set = set(type_slugs)
+    applicable = _applicable_blueprints(all_blueprints, type_slug_set)
+    if not applicable:
+        return 0
+
+    props = await _fetch_project_props(db, project_id)
+
+    # Collect prop_name → default for every unset property with a default.
+    # Use an ordered dict so later (higher-priority) blueprints win.
+    defaults: dict[str, typing.Any] = {}
+    for bp in applicable:
+        for prop_name, prop_schema in (
+            bp.json_schema.properties or {}
+        ).items():
+            if not _SAFE_PROP_RE.match(prop_name):
+                LOGGER.warning(
+                    'Skipping unsafe blueprint property name %r', prop_name
+                )
+                continue
+            if not _is_missing(props.get(prop_name)):
+                continue
+            default = getattr(prop_schema, 'default', None)
+            if default is not None:
+                defaults[prop_name] = default
+
+    if not defaults:
+        return 0
+
+    # Build a single SET clause; parameter names are indexed to avoid
+    # collisions with the property names themselves.
+    set_parts = [f'p.{k} = {{v{i}}}' for i, k in enumerate(defaults)]
+    cypher = (
+        'MATCH (p:Project {{id: {project_id}}}) SET '
+        + ', '.join(set_parts)
+        + ' RETURN p.id AS id'
+    )
+    params: dict[str, typing.Any] = {'project_id': project_id}
+    for i, (_, v) in enumerate(defaults.items()):
+        params[f'v{i}'] = v
+
+    await db.execute(cypher, params, ['id'])
+    LOGGER.info(
+        'Applied %d blueprint default(s) to project %s: %s',
+        len(defaults),
+        project_id,
+        list(defaults.keys()),
+    )
+    return len(defaults)
+
+
+async def remove_stale_blueprint_properties(
+    db: graph.Graph,
+    project_id: str,
+    type_slugs: list[str],
+) -> int:
+    """Remove blueprint-managed properties no longer in any applicable
+    blueprint.
+
+    Only removes properties defined in *some* blueprint, so core model
+    fields (``id``, ``name``, etc.) are never touched. Stale properties are
+    removed by setting them to ``null`` in a single Cypher ``SET`` clause.
+
+    Returns the number of properties removed.
+    """
+    all_blueprints = await project_blueprints(db)
+    if not all_blueprints:
+        return 0
+
+    type_slug_set = set(type_slugs)
+    applicable = _applicable_blueprints(all_blueprints, type_slug_set)
+    props = await _fetch_project_props(db, project_id)
+
+    stale = [
+        p
+        for p in _stale_blueprint_properties(all_blueprints, applicable, props)
+        if _SAFE_PROP_RE.match(p)
+    ]
+    if not stale:
+        return 0
+
+    # Setting a property to null removes it from the AGE node.
+    set_parts = [f'p.{k} = null' for k in stale]
+    cypher = (
+        'MATCH (p:Project {{id: {project_id}}}) SET '
+        + ', '.join(set_parts)
+        + ' RETURN p.id AS id'
+    )
+    await db.execute(cypher, {'project_id': project_id}, ['id'])
+    LOGGER.info(
+        'Removed %d stale blueprint property/ies from project %s: %s',
+        len(stale),
+        project_id,
+        stale,
+    )
+    return len(stale)

{imbi_api-2.11.2 → imbi_api-2.11.4}/src/imbi_api/endpoints/organizations.py

@@ -34,6 +34,7 @@ from .project_incidents import project_incidents_router
 from .project_lifecycle import project_lifecycle_router
 from .project_logs import project_logs_router
 from .project_plugins import project_plugins_router
+from .project_pr_sync import project_pr_sync_router
 from .project_type_plugins import project_type_plugins_router
 from .project_types import project_types_router
 from .projects import projects_router
@@ -176,6 +177,10 @@ organizations_router.include_router(
     project_commit_sync_router,
     prefix='/{org_slug}/projects/{project_id}/commits',
 )
+organizations_router.include_router(
+    project_pr_sync_router,
+    prefix='/{org_slug}/projects/{project_id}/pull-requests',
+)
 organizations_router.include_router(
     pull_requests_project_router,
     prefix='/{org_slug}/projects/{project_id}/pull-requests',

{imbi_api-2.11.2 → imbi_api-2.11.4}/src/imbi_api/endpoints/project_analysis.py

@@ -29,6 +29,13 @@ from imbi_common.plugins.base import (
 from imbi_common.plugins.errors import PluginCredentialsMissing
 
 from imbi_api.auth import permissions
+from imbi_api.blueprint_compliance import (
+    BLUEPRINT_PLUGIN_ID,
+    BLUEPRINT_PLUGIN_SLUG,
+    apply_blueprint_defaults,
+    check_blueprint_compliance,
+    remove_stale_blueprint_properties,
+)
 from imbi_api.endpoints._helpers import (
     lookup_project_exists_in,
     lookup_project_links,
@@ -381,6 +388,13 @@ async def get_project_analysis(
     return report
 
 
+class ApplyDefaultsResponse(pydantic.BaseModel):
+    """Result of syncing blueprint properties on a project."""
+
+    properties_updated: int
+    properties_removed: int = 0
+
+
 @project_analysis_router.post('/run', response_model=AnalysisReport)
 async def run_project_analysis(
     org_slug: str,
@@ -391,20 +405,27 @@ async def run_project_analysis(
         fastapi.Depends(permissions.require_permission('project:write')),
     ],
 ) -> AnalysisReport:
-    plugins = await resolve_analysis_plugins(db, project_id)
-    if not plugins:
-        report = await _persist_report(
-            db,
-            project_id=project_id,
-            overall_status='pass',
-            triggered_by_user_id=(auth.user.id if auth.user else None),
-            results=[],
+    type_slugs = await lookup_project_type_slugs(db, project_id)
+    compliance_items = await check_blueprint_compliance(
+        db, project_id, type_slugs
+    )
+    compliance_results = [
+        AnalysisResult(
+            slug=item.slug,
+            title=item.title,
+            description=item.description,
+            status=item.status,
+            plugin_slug=BLUEPRINT_PLUGIN_SLUG,
+            plugin_id=BLUEPRINT_PLUGIN_ID,
         )
-        return report
+        for item in compliance_items
+    ]
+
+    plugins = await resolve_analysis_plugins(db, project_id)
     per_plugin = await asyncio.gather(
         *(_run_one(db, org_slug, project_id, rp) for rp in plugins)
     )
-    results: list[AnalysisResult] = []
+    results: list[AnalysisResult] = list(compliance_results)
     for batch in per_plugin:
         results.extend(batch)
     results.sort(key=lambda r: (-_STATUS_RANK.get(r.status, 0), r.title))
@@ -417,3 +438,41 @@ async def run_project_analysis(
         triggered_by_user_id=triggered,
         results=results,
     )
+
+
+@project_analysis_router.post(
+    '/apply-blueprint-defaults',
+    response_model=ApplyDefaultsResponse,
+)
+async def apply_project_blueprint_defaults(
+    org_slug: str,
+    project_id: str,
+    db: graph.Pool,
+    auth: typing.Annotated[
+        permissions.AuthContext,
+        fastapi.Depends(permissions.require_permission('project:write')),
+    ],
+) -> ApplyDefaultsResponse:
+    """Apply blueprint default values to any unset project properties.
+
+    Only sets properties that are currently absent or ``null`` and that
+    have a ``default`` defined in the applicable blueprint schema.
+    Existing values are never overwritten.
+    """
+    del org_slug
+    type_slugs = await lookup_project_type_slugs(db, project_id)
+    count = await apply_blueprint_defaults(db, project_id, type_slugs)
+    removed = await remove_stale_blueprint_properties(
+        db, project_id, type_slugs
+    )
+    if auth.user:
+        LOGGER.info(
+            'User %s applied %d default(s), removed %d stale on project %s',
+            auth.user.id,
+            count,
+            removed,
+            project_id,
+        )
+    return ApplyDefaultsResponse(
+        properties_updated=count, properties_removed=removed
+    )

imbi_api-2.11.4/src/imbi_api/endpoints/project_pr_sync.py

@@ -0,0 +1,85 @@
+"""On-demand PR history sync endpoints (Project Doctor).
+
+``POST /pull-requests/sync`` enqueues a background backfill of the
+project's full pull-request history; ``GET /pull-requests/sync-status``
+returns the last-run state for the UI to poll.  The work runs as a
+Valkey-stream job using the ``github-pr-sync`` plugin's service
+credential, so the endpoint only validates eligibility and enqueues.
+"""
+
+import typing
+
+import fastapi
+import pydantic
+from imbi_common import graph
+
+from imbi_api.auth import permissions
+from imbi_api.plugins.resolution import resolve_plugin
+from imbi_api.pr_sync import service
+from imbi_api.pr_sync.queue import enqueue_pr_sync
+from imbi_api.scoring import OptionalValkeyClient
+
+project_pr_sync_router = fastapi.APIRouter(tags=['Project: Pull Requests'])
+
+
+class PRSyncEnqueueResponse(pydantic.BaseModel):
+    """Result of enqueueing a PR history sync."""
+
+    enqueued: bool
+
+
+@project_pr_sync_router.post('/sync', status_code=202)
+async def sync_pull_requests(
+    org_slug: str,
+    project_id: str,
+    db: graph.Pool,
+    valkey_client: OptionalValkeyClient,
+    auth: typing.Annotated[
+        permissions.AuthContext,
+        fastapi.Depends(
+            permissions.require_permission('project:deployment:write'),
+        ),
+    ],
+) -> PRSyncEnqueueResponse:
+    """Enqueue a full pull-request history backfill for the project.
+
+    Requires the project to have a GitHub deployment plugin (the same
+    gate as deployment resync) and a connected ``github-pr-sync`` plugin
+    to provide the service credential.  Returns ``enqueued=False`` when
+    the job was debounced or Valkey is unavailable.
+    """
+    await resolve_plugin(db, project_id, 'deployment', None)
+    try:
+        await service.check_available(db, project_id)
+    except service.PRSyncUnavailable as exc:
+        raise fastapi.HTTPException(status_code=400, detail=str(exc)) from exc
+    requested_by = auth.principal_name
+    enqueued = await enqueue_pr_sync(
+        valkey_client, org_slug, project_id, requested_by
+    )
+    if enqueued:
+        await service.set_status(
+            db,
+            project_id,
+            status='queued',
+            requested_by=requested_by,
+            retry=False,
+        )
+    return PRSyncEnqueueResponse(enqueued=enqueued)
+
+
+@project_pr_sync_router.get('/sync-status')
+async def get_pr_sync_status(
+    org_slug: str,
+    project_id: str,
+    db: graph.Pool,
+    _auth: typing.Annotated[
+        permissions.AuthContext,
+        fastapi.Depends(
+            permissions.require_permission('project:deployment:read'),
+        ),
+    ],
+) -> service.PRSyncStatus:
+    """Return the project's last PR sync state."""
+    del org_slug
+    return await service.read_status(db, project_id)

{imbi_api-2.11.2 → imbi_api-2.11.4}/src/imbi_api/lifespans.py

@@ -19,6 +19,7 @@ from imbi_api.email.client import EmailClient
 from imbi_api.email.templates import TemplateManager
 from imbi_api.identity import sweeper as identity_sweeper
 from imbi_api.plugins import lifecycle as plugin_lifecycle
+from imbi_api.pr_sync import queue as pr_sync_queue
 from imbi_api.scoring import queue as score_queue
 from imbi_api.storage.client import StorageClient
 
@@ -165,6 +166,39 @@ async def commit_sync_worker_hook() -> abc.AsyncGenerator[None]:
             )
 
 
+@contextlib.asynccontextmanager
+async def pr_sync_worker_hook() -> abc.AsyncGenerator[None]:
+    """Run the on-demand PR-sync consumer loop."""
+    try:
+        client = valkey.get_client()
+    except RuntimeError:
+        LOGGER.warning('Valkey unavailable; pr-sync worker not started')
+        yield None
+        return
+    if _graph is None:
+        LOGGER.warning('Graph not ready; pr-sync worker not started')
+        yield None
+        return
+    stop = asyncio.Event()
+    LOGGER.info('PR-sync worker starting')
+    consumer_task = asyncio.create_task(
+        pr_sync_queue.consume_pr_sync(client, _graph, stop=stop)
+    )
+    try:
+        yield None
+    finally:
+        stop.set()
+        consumer_task.cancel()
+        try:
+            await consumer_task
+        except asyncio.CancelledError:
+            pass
+        except Exception:  # noqa: BLE001
+            LOGGER.warning(
+                'PR-sync worker task exited with error', exc_info=True
+            )
+
+
 @contextlib.asynccontextmanager
 async def score_worker_hook() -> abc.AsyncGenerator[None]:
     """Run the score-recompute consumer and the daily tick."""