Fixing automatic product_number assignment

.claude/settings.local.json

@@ -30,7 +30,11 @@
       "Bash(lsof -ti:8000 -sTCP:LISTEN)",
       "Bash(xargs -r kill)",
       "Bash(rm -f /tmp/fg_cookies.txt /private/tmp/claude-501/-Users-roddis-dev-armament-fitguide/7873fd9c-2f2b-4583-877e-72fc88718f24/scratchpad/smoke_sort.py)",
-      "Bash(curl -s -o /dev/null -w \"%{http_code}\\\\n\" http://localhost:8000/login)"
+      "Bash(curl -s -o /dev/null -w \"%{http_code}\\\\n\" http://localhost:8000/login)",
+      "Bash(curl -s -b /tmp/fg_cookies.txt http://localhost:8000__TRACKED_VAR__)",
+      "Bash(sqlite3 app.db \"PRAGMA foreign_keys=ON; SELECT scope_model_id FROM augmented_parts WHERE id=1862;\")",
+      "Bash(sqlite3 app.db \"SELECT id, name FROM scope_models WHERE name='Viper';\")",
+      "Bash(sqlite3 app.db \"SELECT COUNT\\(*\\) FROM augmented_parts WHERE scope_model_id=\\(SELECT id FROM scope_models WHERE name='Viper'\\);\")"
     ]
   }
 }

CLAUDE.md

@@ -87,7 +87,7 @@ The business domain, independent of the auth/RBAC skeleton:
 - **`app/services/scope_import.py`** is a separate, manually-triggered bulk
   importer: reads an uploaded `.xlsx` of third-party scopes, upserting by
   `product_number` (→ `AugmentedPart.sku`) and creating `ScopeModel`,
-  `ScopeInfo`, up to three `AttachmentPoint`s, and up to two `Fit`s per row
+  `ScopeInfo`, up to two `AttachmentPoint`s, and up to two `Fit`s per row
   (see the module docstring for the full column mapping).
 - **`app/services/scope_guide.py`** assembles the `/scopes` page: one row per
   Scope-type `AugmentedPart`, one column per other `PartType`, each cell

FitGuide.md

@@ -21,3 +21,4 @@
 - Models
 - Colours
 - Part Types
+- Notes

alembic/versions/1b99be8a9b1e_add_fits_tables.py

@@ -31,10 +31,16 @@ def upgrade() -> None:
             nullable=False,
         ),
         sa.Column(
-            "created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
         ),
         sa.Column(
-            "updated_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False
+            "updated_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
         ),
         sa.ForeignKeyConstraint(
             ["attachment_point_a_id"], ["attachment_points.id"], ondelete="CASCADE"
@@ -59,7 +65,10 @@ def upgrade() -> None:
         sa.Column("username", sa.String(length=255), nullable=False),
         sa.Column("body", sa.Text(), nullable=False),
         sa.Column(
-            "created_at", sa.DateTime(timezone=True), server_default=sa.func.now(), nullable=False
+            "created_at",
+            sa.DateTime(timezone=True),
+            server_default=sa.func.now(),
+            nullable=False,
         ),
         sa.ForeignKeyConstraint(["fit_id"], ["fits.id"], ondelete="CASCADE"),
         sa.ForeignKeyConstraint(["user_id"], ["users.id"], ondelete="SET NULL"),

alembic/versions/a3f7c19b2d40_add_objective_lens_diameter_to_scope_infos.py

@@ -0,0 +1,28 @@
+"""add_objective_lens_diameter_to_scope_infos
+
+Revision ID: a3f7c19b2d40
+Revises: 8012c00b0c04
+Create Date: 2026-08-04 00:00:00.000000
+"""
+
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+
+# revision identifiers, used by Alembic.
+revision: str = "a3f7c19b2d40"
+down_revision: Union[str, None] = "8012c00b0c04"
+branch_labels: Union[str, Sequence[str], None] = None
+depends_on: Union[str, Sequence[str], None] = None
+
+
+def upgrade() -> None:
+    op.add_column(
+        "scope_infos",
+        sa.Column("objective_lens_diameter_mm", sa.Float(), nullable=True),
+    )
+
+
+def downgrade() -> None:
+    op.drop_column("scope_infos", "objective_lens_diameter_mm")

app/api/fits.py

@@ -67,9 +67,7 @@ async def create_fit(
     if ap_a is None or ap_b is None:
         raise HTTPException(status_code=404, detail="Attachment point not found")
     if ap_a.augmented_part_id == ap_b.augmented_part_id:
-        raise HTTPException(
+        raise HTTPException(status_code=422, detail="a part cannot fit itself")
-            status_code=422, detail="a part cannot fit itself"
-        )
     existing = await fit_crud.get_by_attachment_points(db, ap_a, ap_b)
     if existing is not None:
         raise HTTPException(status_code=409, detail="Fit already exists")

app/core/database.py

@@ -35,6 +35,7 @@ if engine.sync_engine.dialect.name == "sqlite":
         cursor.execute("PRAGMA busy_timeout=5000")
         cursor.close()
 
+
 AsyncSessionLocal = async_sessionmaker(
     engine,
     class_=AsyncSession,

app/crud/attachment_point.py

@@ -2,6 +2,7 @@ from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.models.attachment_point import AttachmentPoint
+from app.models.attachment_point_name import AttachmentPointName
 
 _RELATIONSHIPS = [
     "attachment_point_name",
@@ -27,6 +28,24 @@ async def list_for_augmented_part(
     return list(result.scalars().all())
 
 
+async def list_by_augmented_parts_and_name(
+    db: AsyncSession, augmented_part_ids: list[int], name: str
+) -> list[AttachmentPoint]:
+    """AttachmentPoints named ``name`` for the given augmented parts, fetched in
+    one query."""
+    if not augmented_part_ids:
+        return []
+    result = await db.execute(
+        select(AttachmentPoint)
+        .join(AttachmentPoint.attachment_point_name)
+        .where(
+            AttachmentPoint.augmented_part_id.in_(augmented_part_ids),
+            AttachmentPointName.name == name,
+        )
+    )
+    return list(result.scalars().all())
+
+
 async def list_all(
     db: AsyncSession, skip: int = 0, limit: int = 100
 ) -> list[AttachmentPoint]:

app/crud/role.py

@@ -23,9 +23,7 @@ async def get_default(db: AsyncSession) -> Role | None:
 
 async def set_default(db: AsyncSession, role: Role) -> Role:
     """Make ``role`` the sole default, clearing the flag on every other role."""
-    await db.execute(
+    await db.execute(sa_update(Role).where(Role.id != role.id).values(is_default=False))
-        sa_update(Role).where(Role.id != role.id).values(is_default=False)
-    )
     role.is_default = True
     await db.commit()
     await db.refresh(role)

app/crud/scope_info.py

@@ -24,9 +24,7 @@ async def list_by_augmented_parts(
     if not augmented_part_ids:
         return []
     result = await db.execute(
-        select(ScopeInfo).where(
+        select(ScopeInfo).where(ScopeInfo.augmented_part_id.in_(augmented_part_ids))
-            ScopeInfo.augmented_part_id.in_(augmented_part_ids)
-        )
     )
     return list(result.scalars().all())
 
@@ -38,6 +36,7 @@ async def create(
     magnification_min: float | None = None,
     magnification_max: float | None = None,
     model_suffix: str | None = None,
+    objective_lens_diameter_mm: float | None = None,
     objective_thread_pitch: str | None = None,
 ) -> ScopeInfo:
     info = ScopeInfo(
@@ -45,6 +44,7 @@ async def create(
         magnification_min=magnification_min,
         magnification_max=magnification_max,
         model_suffix=model_suffix,
+        objective_lens_diameter_mm=objective_lens_diameter_mm,
         objective_thread_pitch=objective_thread_pitch,
     )
     db.add(info)

app/models/scope_info.py

@@ -27,6 +27,11 @@ class ScopeInfo(Base):
     model_suffix: Mapped[str | None] = mapped_column(
         String, nullable=True, default=None
     )
+    # The lens diameter is a descriptive attribute (the "50" in "3-18x50"), not a
+    # connection dimension — it has no AttachmentPoint.
+    objective_lens_diameter_mm: Mapped[float | None] = mapped_column(
+        Float, nullable=True, default=None
+    )
     # Kept as the raw string from the sheet (e.g. "0.75", "1/16") so no precision
     # or notation is lost; the parsed thread lives on its own AttachmentPoint.
     objective_thread_pitch: Mapped[str | None] = mapped_column(

app/schemas/scope_info.py

@@ -5,6 +5,7 @@ class ScopeInfoBase(BaseModel):
     magnification_min: float | None = None
     magnification_max: float | None = None
     model_suffix: str | None = None
+    objective_lens_diameter_mm: float | None = None
     objective_thread_pitch: str | None = None
 
 

app/services/fit_matching.py

@@ -142,9 +142,7 @@ async def _reconcile(
             for own_ap in own_points:
                 for other_ap in points_by_part.get(other_id, []):
                     if attachment_points_match(own_ap, other_ap):
-                        candidate_pairs.add(
+                        candidate_pairs.add(_canonical_pair(own_ap.id, other_ap.id))
-                            _canonical_pair(own_ap.id, other_ap.id)
-                        )
 
     result = RecomputeResult()
 
@@ -171,7 +169,9 @@ async def _reconcile(
     return result
 
 
-async def recompute_for_part(db: AsyncSession, augmented_part_id: int) -> RecomputeResult:
+async def recompute_for_part(
+    db: AsyncSession, augmented_part_id: int
+) -> RecomputeResult:
     """Reconcile Possible fits involving this part against the current algorithm.
 
     Creates Possible fits for newly-matching attachment point pairs, and removes

app/services/jobs.py

@@ -0,0 +1,74 @@
+"""Lightweight in-process tracking for long-running admin operations.
+
+Jobs live in a module-level dict, so this only works correctly for a single
+OS process (the app's current deployment: one uvicorn worker, no multi-process
+or multi-replica setup — see ``entrypoint.sh`` / ``docker-compose.yml``). If
+the app is ever scaled to multiple workers/replicas, this needs to move to
+shared storage (a DB table, Redis) so a poll request landing on a different
+process can still see the job.
+"""
+
+from __future__ import annotations
+
+import asyncio
+import uuid
+from collections.abc import Awaitable, Callable
+from dataclasses import dataclass, field
+from datetime import UTC, datetime
+
+_MAX_FINISHED_AGE_SECONDS = 3600
+
+
+@dataclass
+class Job:
+    id: str
+    kind: str
+    status: str = "running"  # running | done | error
+    message: str = "Working…"
+    result: object | None = None
+    created_at: datetime = field(default_factory=lambda: datetime.now(UTC))
+    finished_at: datetime | None = None
+
+
+_jobs: dict[str, Job] = {}
+
+
+def get(job_id: str) -> Job | None:
+    return _jobs.get(job_id)
+
+
+def _evict_stale() -> None:
+    now = datetime.now(UTC)
+    stale = [
+        job_id
+        for job_id, job in _jobs.items()
+        if job.finished_at
+        and (now - job.finished_at).total_seconds() > _MAX_FINISHED_AGE_SECONDS
+    ]
+    for job_id in stale:
+        del _jobs[job_id]
+
+
+def start(kind: str, run: Callable[[Job], Awaitable[None]]) -> Job:
+    """Create a job, launch ``run(job)`` in the background, and return it immediately.
+
+    ``run`` is responsible for updating ``job.status``/``job.message``/``job.result``
+    to reflect the outcome, including catching its own errors. Any exception that
+    escapes anyway is caught here as a last resort so the job doesn't hang forever
+    in "running" state.
+    """
+    _evict_stale()
+    job = Job(id=uuid.uuid4().hex, kind=kind)
+    _jobs[job.id] = job
+
+    async def _runner() -> None:
+        try:
+            await run(job)
+        except Exception as exc:
+            job.status = "error"
+            job.message = f"{kind} failed: {exc}"
+        finally:
+            job.finished_at = datetime.now(UTC)
+
+    asyncio.create_task(_runner())
+    return job

app/services/scope_guide.py

@@ -50,9 +50,7 @@ async def build(
         }
     """
     part_types = await part_type_crud.list_all(db, limit=1000)
-    scope_type = next(
+    scope_type = next((pt for pt in part_types if pt.name == SCOPE_TYPE_NAME), None)
-        (pt for pt in part_types if pt.name == SCOPE_TYPE_NAME), None
-    )
     column_types = [
         pt for pt in part_types if scope_type is None or pt.id != scope_type.id
     ]
@@ -94,9 +92,7 @@ async def build(
 
     # cell_map[scope_id][type_id][other_part_id] -> {"part", "label"}, dedup'd so a
     # part appears once per cell, keeping its strongest fit label.
-    cell_map: dict[int, dict[int, dict[int, dict]]] = {
+    cell_map: dict[int, dict[int, dict[int, dict]]] = {sid: {} for sid in scope_ids}
-        sid: {} for sid in scope_ids
-    }
     for fit in fits:
         scope_id, other_id = _scope_and_other(fit, scope_ids)
         if scope_id is None:
@@ -121,7 +117,11 @@ async def build(
         if fits_part_type_id is not None and fits_part_type_id not in cells:
             continue  # scope has no fit for the required accessory type
         rows.append(
-            {"scope": scope, "info": infos.get(scope.id), "cells": cells}
+            {
+                "scope": scope,
+                "info": infos.get(scope.id),
+                "cells": cells,
+            }
         )
 
     return {"column_types": column_types, "rows": rows}

app/services/scope_import.py

@@ -2,7 +2,7 @@
 
 The spreadsheet describes parts of PartType "Scope". Each row maps onto an
 AugmentedPart (keyed on ``product_number`` → ``sku``, so re-importing upserts),
-a ScopeModel, a ScopeInfo record for the scope-specific fields, up to three
+a ScopeModel, a ScopeInfo record for the scope-specific fields, up to two
 attachment points, and up to two Fits against other parts.
 
 Column → destination
@@ -14,9 +14,9 @@ model_suffix                        → ScopeInfo.model_suffix (+ description)
 sub_part_type                       → SubPartType (get-or-create under "Scope")
 product_number                      → AugmentedPart.sku  (also the upsert / fit-lookup key)
 magnification_min / _max            → ScopeInfo
+objective_lens_diameter_mm          → ScopeInfo (descriptive only, no attachment point)
 objective_thread_pitch              → ScopeInfo
 ocular_outer_diameter_mm            → StaticConnection + AttachmentPoint "Ocular"
-objective_lens_outside_diameter_mm  → StaticConnection + AttachmentPoint "Objective"
 objective_thread                    → ISO/UNC thread + AttachmentPoint "Objective"
 ocular_fit                          → Fit: scope's Ocular AP ↔ referenced part's first AP
 objective_fit                       → Fit: scope's Objective AP ↔ referenced part's first AP
@@ -68,7 +68,7 @@ EXPECTED_COLUMNS = [
     "model",
     "magnification_min",
     "magnification_max",
-    "objective_lens_outside_diameter_mm",
+    "objective_lens_diameter_mm",
     "model_suffix",
     "sub_part_type",
     "product_number",
@@ -250,7 +250,9 @@ async def import_scopes(db: AsyncSession, rows: list[dict]) -> ScopeImportResult
     for offset, row in enumerate(rows):
         # +2: 1-based, and the header occupies row 1.
         row_num = offset + 2
-        product_number = _text(row.get("product_number")) or _text(row.get("model"))
+        model_suffix = _text(row.get("model_suffix"))
+        default_product_number = f"{_text(row.get('model'))} {row.get('magnification_min')}-{row.get('magnification_max')}x{row.get('objective_lens')} {row.get('model_suffix')}".strip()
+        product_number = _text(row.get("product_number")) or default_product_number
         result = ScopeImportRowResult(
             row=row_num, product_number=product_number, status="skipped", messages=[]
         )
@@ -330,6 +332,7 @@ async def import_scopes(db: AsyncSession, rows: list[dict]) -> ScopeImportResult
                 magnification_min=_num(row.get("magnification_min")),
                 magnification_max=_num(row.get("magnification_max")),
                 model_suffix=model_suffix,
+                objective_lens_diameter_mm=_num(row.get("objective_lens_diameter_mm")),
                 objective_thread_pitch=_text(row.get("objective_thread_pitch")),
             )
 
@@ -350,34 +353,23 @@ async def import_scopes(db: AsyncSession, rows: list[dict]) -> ScopeImportResult
                     od_mm=ocular_od,
                 )
 
-            objective_static_ap = None
+            # The objective attachment point comes from the thread alone — the
-            objective_od = _num(row.get("objective_lens_outside_diameter_mm"))
+            # lens diameter is a descriptive attribute, not a connection.
-            if objective_od is not None:
-                objective_static_ap = await _static_ap(
-                    db,
-                    augmented_part_id=part.id,
-                    label=OBJECTIVE_LABEL,
-                    od_mm=objective_od,
-                )
-
             objective_thread_spec = _text(row.get("objective_thread"))
-            objective_thread_ap = None
+            objective_ap = None
             if objective_thread_spec:
-                objective_thread_ap = await _thread_ap(
+                objective_ap = await _thread_ap(
                     db,
                     augmented_part_id=part.id,
                     label=OBJECTIVE_LABEL,
                     spec=objective_thread_spec,
                 )
-                if objective_thread_ap is None:
+                if objective_ap is None:
                     result.messages.append(
                         f"could not parse objective_thread "
                         f"'{objective_thread_spec}'"
                     )
 
-            # For objective_fit prefer the lens-OD point, falling back to the thread.
-            objective_ap = objective_static_ap or objective_thread_ap
-
             staged.append((row, ocular_ap, objective_ap, part.id, result))
             row_results.append(result)
         except Exception as exc:  # noqa: BLE001 - report, don't abort the batch

app/templates/_scopes_table_card.html

@@ -1,11 +1,17 @@
 {%- macro mag(v) -%}{{ v | int if v == v | int else v | round(1) }}{%- endmacro -%}
-{%- macro magnification(info) -%}
+{%- macro magnification_range(info) -%}
   {%- if info and info.magnification_min is not none and info.magnification_max is not none -%}
-    {{ mag(info.magnification_min) }}–{{ mag(info.magnification_max) }}×
+    {{ mag(info.magnification_min) }}-{{ mag(info.magnification_max) }}
   {%- elif info and info.magnification_min is not none -%}
-    {{ mag(info.magnification_min) }}×
+    {{ mag(info.magnification_min) }}
   {%- elif info and info.magnification_max is not none -%}
-    {{ mag(info.magnification_max) }}×
+    {{ mag(info.magnification_max) }}
+  {%- endif -%}
+{%- endmacro -%}
+{%- macro magnification(info) -%}
+  {%- set range = magnification_range(info) -%}
+  {%- if range -%}
+    {{ range }}x{% if info.objective_lens_diameter_mm is not none %}{{ mag(info.objective_lens_diameter_mm) }}{% endif %}
   {%- else -%}
     <span class="muted">—</span>
   {%- endif -%}

app/templates/admin/_job_progress.html

@@ -0,0 +1,7 @@
+<div id="{{ container_id }}"
+     hx-get="{{ poll_url }}"
+     hx-trigger="load delay:1s"
+     hx-swap="outerHTML"
+     class="{{ extra_class or '' }}">
+  <p class="muted">⏳ {{ job.message }}</p>
+</div>

app/templates/admin/_job_progress_inline.html

@@ -0,0 +1,5 @@
+<span id="{{ container_id }}"
+      hx-get="{{ poll_url }}"
+      hx-trigger="load delay:1s"
+      hx-swap="outerHTML"
+      class="muted">⏳ {{ job.message }}</span>

app/templates/admin/_scope_import_result.html

@@ -1,3 +1,4 @@
+<div id="{{ container_id or 'scope-import-result-body' }}">
 {% if error %}
 <div class="card">
   <p style="color:var(--color-danger,#c00)">{{ error }}</p>
@@ -39,3 +40,4 @@
   {% endif %}
 </div>
 {% endif %}
+</div>

app/templates/admin/augmented_part_detail.html

@@ -44,6 +44,12 @@
           {% else %}—{% endif %}
         </dd>
         <dt>Model suffix</dt><dd>{{ scope_info.model_suffix or "—" }}</dd>
+        <dt>Objective lens diameter</dt>
+        <dd>
+          {% if scope_info.objective_lens_diameter_mm is not none %}
+            {{ scope_info.objective_lens_diameter_mm }} mm
+          {% else %}—{% endif %}
+        </dd>
         <dt>Objective thread</dt><dd>{{ scope_info.objective_thread_pitch or "—" }}</dd>
       </dl>
     </div>

app/templates/base.html

@@ -4,6 +4,7 @@
   <meta charset="utf-8">
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <title>{% block title %}{{ app_name }}{% endblock %}</title>
+  <link rel="icon" href="/static/favicon.ico" sizes="any">
   <link rel="stylesheet" href="/static/css/style.css">
   <script src="https://unpkg.com/htmx.org@1.9.12"
           integrity="sha384-ujb1lZYygJmzgSwoxRggbCHcjc0rB2XoQrxeTUQyRjrOnlCoYta87iKBWq3EsdM2"

app/web/admin.py

@@ -16,7 +16,7 @@ from fastapi import (
 from fastapi.responses import HTMLResponse, RedirectResponse, Response
 from sqlalchemy.ext.asyncio import AsyncSession
 
-from app.core.database import get_db
+from app.core.database import AsyncSessionLocal, get_db
 from app.crud import audit as audit_crud
 from app.crud import augmented_part as augmented_part_crud
 from app.crud import augmented_part_note as augmented_part_note_crud
@@ -44,6 +44,7 @@ from app.models.unc_thread import UncSeries
 from app.models.user import User
 from app.services import augmented_part_sync as augmented_part_sync_service
 from app.services import fit_matching as fit_matching_service
+from app.services import jobs
 from app.services import odata as odata_service
 from app.services import scope_import as scope_import_service
 from app.web.templates import templates
@@ -1469,11 +1470,21 @@ async def scope_import_page(
     )
 
 
+_SCOPE_IMPORT_STATUS_ID = "scope-import-status"
+
+
+def _scope_import_progress_ctx(job: jobs.Job) -> dict:
+    return {
+        "container_id": _SCOPE_IMPORT_STATUS_ID,
+        "poll_url": f"/admin/scope-import/jobs/{job.id}",
+        "job": job,
+    }
+
+
 @router.post("/scope-import", response_class=HTMLResponse)
 async def upload_scope_import(
     request: Request,
     file: UploadFile = File(...),
-    db: AsyncSession = Depends(get_db),
     actor: User = Depends(web_require("augmented_parts:write")),
 ):
     filename = file.filename or ""
@@ -1481,33 +1492,74 @@ async def upload_scope_import(
         return templates.TemplateResponse(
             request,
             "admin/_scope_import_result.html",
-            {"error": "Expected an .xlsx spreadsheet."},
+            {
+                "error": "Expected an .xlsx spreadsheet.",
+                "container_id": _SCOPE_IMPORT_STATUS_ID,
+            },
         )
     data = await file.read()
-    try:
+    actor_id = actor.id
-        result = await scope_import_service.import_from_bytes(db, data)
+
-    except Exception as exc:  # noqa: BLE001
+    async def _run(job: jobs.Job) -> None:
+        async with AsyncSessionLocal() as db:
+            try:
+                result = await scope_import_service.import_from_bytes(db, data)
+            except Exception as exc:  # noqa: BLE001
+                job.status = "error"
+                job.message = f"Could not read spreadsheet: {exc}"
+                return
+            actor_row = await user_crud.get(db, actor_id)
+            await audit_crud.log(
+                db,
+                actor=actor_row,
+                action="update",
+                resource_type="AugmentedPart",
+                resource_id=None,
+                description=(
+                    f"Scope import ({filename}): {result.created} created, "
+                    f"{result.updated} updated, {result.skipped} skipped, "
+                    f"{result.errors} errors"
+                ),
+            )
+            job.status = "done"
+            job.result = result
+
+    job = jobs.start("scope_import", _run)
+    return templates.TemplateResponse(
+        request, "admin/_job_progress.html", _scope_import_progress_ctx(job)
+    )
+
+
+@router.get("/scope-import/jobs/{job_id}", response_class=HTMLResponse)
+async def scope_import_job_status(
+    request: Request,
+    job_id: str,
+    _: User = Depends(web_require("augmented_parts:write")),
+):
+    job = jobs.get(job_id)
+    if job is None:
         return templates.TemplateResponse(
             request,
             "admin/_scope_import_result.html",
-            {"error": f"Could not read spreadsheet: {exc}"},
+            {
+                "error": "Import job not found — it may have expired.",
+                "container_id": _SCOPE_IMPORT_STATUS_ID,
+            },
+        )
+    if job.status == "running":
+        return templates.TemplateResponse(
+            request, "admin/_job_progress.html", _scope_import_progress_ctx(job)
+        )
+    if job.status == "error":
+        return templates.TemplateResponse(
+            request,
+            "admin/_scope_import_result.html",
+            {"error": job.message, "container_id": _SCOPE_IMPORT_STATUS_ID},
         )
-    await audit_crud.log(
-        db,
-        actor=actor,
-        action="update",
-        resource_type="AugmentedPart",
-        resource_id=None,
-        description=(
-            f"Scope import ({filename}): {result.created} created, "
-            f"{result.updated} updated, {result.skipped} skipped, "
-            f"{result.errors} errors"
-        ),
-    )
     return templates.TemplateResponse(
         request,
         "admin/_scope_import_result.html",
-        {"result": result},
+        {"result": job.result, "container_id": _SCOPE_IMPORT_STATUS_ID},
     )
 
 
@@ -1645,38 +1697,89 @@ async def create_augmented_part(
     )
 
 
+_AUGMENTED_PARTS_SYNC_TARGET_ID = "augmented-part-list"
+
+
 @router.post("/augmented-parts/sync", response_class=HTMLResponse)
 async def sync_augmented_parts(
     request: Request,
-    db: AsyncSession = Depends(get_db),
     actor: User = Depends(web_require("augmented_parts:write")),
 ):
-    try:
+    actor_id = actor.id
-        result = await augmented_part_sync_service.sync(db)
+
-        await audit_crud.log(
+    async def _run(job: jobs.Job) -> None:
-            db,
+        async with AsyncSessionLocal() as db:
-            actor=actor,
+            try:
-            action="update",
+                result = await augmented_part_sync_service.sync(db)
-            resource_type="AugmentedPart",
+            except Exception as exc:
-            resource_id=None,
+                job.status = "error"
-            description=(
+                job.message = f"Sync failed: {exc}"
-                f"Sync: {result.created} created, {result.deleted} deleted, "
+                return
-                f"{result.skipped} skipped (no type match)"
+            actor_row = await user_crud.get(db, actor_id)
-            ),
+            await audit_crud.log(
-        )
+                db,
-        sync_result = (
+                actor=actor_row,
-            f"Sync complete: {result.created} created, {result.deleted} deleted"
+                action="update",
-            + (
+                resource_type="AugmentedPart",
-                f", {result.skipped} skipped (type not recognised)"
+                resource_id=None,
-                if result.skipped
+                description=(
-                else ""
+                    f"Sync: {result.created} created, {result.deleted} deleted, "
+                    f"{result.skipped} skipped (no type match)"
+                ),
             )
-            + "."
+            job.status = "done"
+            job.message = (
+                f"Sync complete: {result.created} created, {result.deleted} deleted"
+                + (
+                    f", {result.skipped} skipped (type not recognised)"
+                    if result.skipped
+                    else ""
+                )
+                + "."
+            )
+
+    job = jobs.start("augmented_part_sync", _run)
+    return templates.TemplateResponse(
+        request,
+        "admin/_job_progress.html",
+        {
+            "container_id": _AUGMENTED_PARTS_SYNC_TARGET_ID,
+            "poll_url": f"/admin/augmented-parts/sync/jobs/{job.id}",
+            "job": job,
+        },
+    )
+
+
+@router.get("/augmented-parts/sync/jobs/{job_id}", response_class=HTMLResponse)
+async def augmented_parts_sync_job_status(
+    request: Request,
+    job_id: str,
+    db: AsyncSession = Depends(get_db),
+    _: User = Depends(web_require("augmented_parts:write")),
+):
+    job = jobs.get(job_id)
+    if job is None:
+        form_ctx = await _augmented_part_form_ctx(db)
+        return templates.TemplateResponse(
+            request,
+            "admin/_augmented_parts_table.html",
+            {
+                **form_ctx,
+                **await _default_augmented_parts_table_ctx(db),
+                "sync_result": None,
+                "sync_error": "Sync job not found — it may have expired.",
+            },
+        )
+    if job.status == "running":
+        return templates.TemplateResponse(
+            request,
+            "admin/_job_progress.html",
+            {
+                "container_id": _AUGMENTED_PARTS_SYNC_TARGET_ID,
+                "poll_url": f"/admin/augmented-parts/sync/jobs/{job_id}",
+                "job": job,
+            },
         )
-        sync_error = None
-    except Exception as exc:
-        sync_result = None
-        sync_error = f"Sync failed: {exc}"
     form_ctx = await _augmented_part_form_ctx(db)
     return templates.TemplateResponse(
         request,
@@ -1684,8 +1787,8 @@ async def sync_augmented_parts(
         {
             **form_ctx,
             **await _default_augmented_parts_table_ctx(db),
-            "sync_result": sync_result,
+            "sync_result": job.message if job.status == "done" else None,
-            "sync_error": sync_error,
+            "sync_error": job.message if job.status == "error" else None,
         },
     )
 
@@ -2355,32 +2458,94 @@ async def augmented_part_fits(
     return templates.TemplateResponse(request, "admin/_augmented_part_fits.html", ctx)
 
 
+def _augmented_part_fits_target_id(augmented_part_id: int) -> str:
+    return f"ap-{augmented_part_id}-fits"
+
+
 @router.post(
     "/augmented-parts/{augmented_part_id}/fits/recompute", response_class=HTMLResponse
 )
 async def recompute_augmented_part_fits(
     request: Request,
     augmented_part_id: int,
+    actor: User = Depends(web_require("fits:write")),
+):
+    actor_id = actor.id
+
+    async def _run(job: jobs.Job) -> None:
+        async with AsyncSessionLocal() as db:
+            result = await fit_matching_service.recompute_for_part(
+                db, augmented_part_id
+            )
+            actor_row = await user_crud.get(db, actor_id)
+            await audit_crud.log(
+                db,
+                actor=actor_row,
+                action="update",
+                resource_type="Fit",
+                resource_id=augmented_part_id,
+                description=(
+                    f"Recomputed fits for AugmentedPart #{augmented_part_id}: "
+                    f"{result.created} created, {result.removed} removed"
+                ),
+            )
+            job.status = "done"
+            job.message = f"{result.created} created, {result.removed} removed."
+
+    job = jobs.start("fit_recompute_part", _run)
+    return templates.TemplateResponse(
+        request,
+        "admin/_job_progress.html",
+        {
+            "container_id": _augmented_part_fits_target_id(augmented_part_id),
+            "poll_url": f"/admin/augmented-parts/{augmented_part_id}/fits/recompute/jobs/{job.id}",
+            "job": job,
+            "extra_class": "ap-inline-section",
+        },
+    )
+
+
+@router.get(
+    "/augmented-parts/{augmented_part_id}/fits/recompute/jobs/{job_id}",
+    response_class=HTMLResponse,
+)
+async def augmented_part_fits_recompute_job_status(
+    request: Request,
+    augmented_part_id: int,
+    job_id: str,
     db: AsyncSession = Depends(get_db),
     actor: User = Depends(web_require("fits:write")),
 ):
-    result = await fit_matching_service.recompute_for_part(db, augmented_part_id)
+    job = jobs.get(job_id)
-    await audit_crud.log(
+    if job is None:
-        db,
+        ctx = await _augmented_part_fits_ctx(
-        actor=actor,
+            db,
-        action="update",
+            augmented_part_id,
-        resource_type="Fit",
+            can_write=_can_write_fits(actor),
-        resource_id=augmented_part_id,
+            error="Recompute job not found — it may have expired.",
-        description=(
+        )
-            f"Recomputed fits for AugmentedPart #{augmented_part_id}: "
+        return templates.TemplateResponse(
-            f"{result.created} created, {result.removed} removed"
+            request, "admin/_augmented_part_fits.html", ctx
-        ),
+        )
-    )
+    if job.status == "running":
+        return templates.TemplateResponse(
+            request,
+            "admin/_job_progress.html",
+            {
+                "container_id": _augmented_part_fits_target_id(augmented_part_id),
+                "poll_url": (
+                    f"/admin/augmented-parts/{augmented_part_id}/fits/recompute/jobs/{job_id}"
+                ),
+                "job": job,
+                "extra_class": "ap-inline-section",
+            },
+        )
     ctx = await _augmented_part_fits_ctx(
         db,
         augmented_part_id,
         can_write=_can_write_fits(actor),
-        message=f"{result.created} created, {result.removed} removed.",
+        message=job.message if job.status == "done" else None,
+        error=job.message if job.status == "error" else None,
     )
     return templates.TemplateResponse(request, "admin/_augmented_part_fits.html", ctx)
 
@@ -2588,29 +2753,73 @@ async def delete_augmented_part_fit(
     return templates.TemplateResponse(request, "admin/_augmented_part_fits.html", ctx)
 
 
+_ALL_FITS_RECOMPUTE_STATUS_ID = "fits-recompute-status"
+
+
 @router.post("/augmented-parts/fits/recompute", response_class=HTMLResponse)
 async def recompute_all_fits(
     request: Request,
-    db: AsyncSession = Depends(get_db),
     actor: User = Depends(web_require("fits:write")),
 ):
-    result = await fit_matching_service.recompute_all(db)
+    actor_id = actor.id
-    await audit_crud.log(
+
-        db,
+    async def _run(job: jobs.Job) -> None:
-        actor=actor,
+        async with AsyncSessionLocal() as db:
-        action="update",
+            result = await fit_matching_service.recompute_all(db)
-        resource_type="Fit",
+            actor_row = await user_crud.get(db, actor_id)
-        resource_id=None,
+            await audit_crud.log(
-        description=(
+                db,
-            f"Recomputed fits for all parts: {result.created} created, "
+                actor=actor_row,
-            f"{result.removed} removed"
+                action="update",
-        ),
+                resource_type="Fit",
-    )
+                resource_id=None,
-    return HTMLResponse(
+                description=(
-        f"Recompute complete: {result.created} created, {result.removed} removed."
+                    f"Recomputed fits for all parts: {result.created} created, "
+                    f"{result.removed} removed"
+                ),
+            )
+            job.status = "done"
+            job.message = (
+                f"Recompute complete: {result.created} created, "
+                f"{result.removed} removed."
+            )
+
+    job = jobs.start("fit_recompute_all", _run)
+    return templates.TemplateResponse(
+        request,
+        "admin/_job_progress_inline.html",
+        {
+            "container_id": _ALL_FITS_RECOMPUTE_STATUS_ID,
+            "poll_url": f"/admin/augmented-parts/fits/recompute/jobs/{job.id}",
+            "job": job,
+        },
     )
 
 
+@router.get(
+    "/augmented-parts/fits/recompute/jobs/{job_id}", response_class=HTMLResponse
+)
+async def recompute_all_fits_job_status(
+    request: Request,
+    job_id: str,
+    _: User = Depends(web_require("fits:write")),
+):
+    job = jobs.get(job_id)
+    if job is None:
+        return HTMLResponse("Recompute job not found — it may have expired.")
+    if job.status == "running":
+        return templates.TemplateResponse(
+            request,
+            "admin/_job_progress_inline.html",
+            {
+                "container_id": _ALL_FITS_RECOMPUTE_STATUS_ID,
+                "poll_url": f"/admin/augmented-parts/fits/recompute/jobs/{job_id}",
+                "job": job,
+            },
+        )
+    return HTMLResponse(job.message)
+
+
 # --- Augmented Part Notes -------------------------------------------------
 
 

tests/test_admin_background_jobs.py

@@ -0,0 +1,156 @@
+import asyncio
+import re
+
+import pytest
+
+from app.crud import role as role_crud
+from app.models.attachment_point import AttachmentPoint
+from app.models.attachment_point_name import AttachmentPointName
+from app.models.augmented_part import AugmentedPart
+from app.models.part_type import PartType
+from tests.test_scope_import import _scope_row, _workbook
+
+_JOB_URL_RE = re.compile(r'hx-get="([^"]+/jobs/[^"]+)"')
+
+
+async def _web_login(client, email, password="secret123"):
+    resp = await client.post("/login", data={"email": email, "password": password})
+    assert resp.status_code == 303
+
+
+async def _poll_until_done(client, url, max_tries=50):
+    """Follow the same htmx polling loop a browser would, until no further
+    ``hx-get`` job-status link is present in the response."""
+    body = ""
+    for _ in range(max_tries):
+        resp = await client.get(url)
+        assert resp.status_code == 200
+        body = resp.text
+        match = _JOB_URL_RE.search(body)
+        if not match:
+            return body
+        url = match.group(1)
+        await asyncio.sleep(0.02)
+    raise AssertionError(f"job did not finish after {max_tries} polls: {body!r}")
+
+
+@pytest.mark.asyncio
+async def test_scope_import_runs_in_background(
+    client, seeded, make_user, db_sessionmaker, monkeypatch
+):
+    monkeypatch.setattr("app.web.admin.AsyncSessionLocal", db_sessionmaker)
+    async with db_sessionmaker() as db:
+        perms = seeded["perms"]
+        editor = await role_crud.create(
+            db,
+            name="scope-import-editor",
+            permission_ids=[perms["augmented_parts:write"].id],
+        )
+        editor_id = editor.id
+    await make_user("importer@example.com", role_ids=[editor_id])
+    await _web_login(client, "importer@example.com")
+
+    data = _workbook([_scope_row(product_number="BG-SCOPE-1")])
+    resp = await client.post(
+        "/admin/scope-import",
+        files={"file": ("scopes.xlsx", data, "application/octet-stream")},
+    )
+    assert resp.status_code == 200
+    assert "scope-import-status" in resp.text
+    match = _JOB_URL_RE.search(resp.text)
+    assert match, resp.text
+
+    final_body = await _poll_until_done(client, match.group(1))
+    assert "1</strong> created" in final_body
+
+
+@pytest.mark.asyncio
+async def test_augmented_parts_sync_runs_in_background(
+    client, seeded, make_user, db_sessionmaker, monkeypatch
+):
+    monkeypatch.setattr("app.web.admin.AsyncSessionLocal", db_sessionmaker)
+    async with db_sessionmaker() as db:
+        perms = seeded["perms"]
+        editor = await role_crud.create(
+            db, name="sync-editor", permission_ids=[perms["augmented_parts:write"].id]
+        )
+        editor_id = editor.id
+    await make_user("syncer@example.com", role_ids=[editor_id])
+    await _web_login(client, "syncer@example.com")
+
+    resp = await client.post("/admin/augmented-parts/sync")
+    assert resp.status_code == 200
+    assert 'id="augmented-part-list"' in resp.text
+    match = _JOB_URL_RE.search(resp.text)
+    assert match, resp.text
+
+    final_body = await _poll_until_done(client, match.group(1))
+    assert "Sync complete" in final_body
+
+
+@pytest.mark.asyncio
+async def test_fit_recompute_for_part_runs_in_background(
+    client, seeded, make_user, db_sessionmaker, monkeypatch
+):
+    monkeypatch.setattr("app.web.admin.AsyncSessionLocal", db_sessionmaker)
+    async with db_sessionmaker() as db:
+        apn = AttachmentPointName(name="Objective")
+        part_t = PartType(name="Scope")
+        db.add_all([apn, part_t])
+        await db.flush()
+        part = AugmentedPart(
+            description="Test scope",
+            colour_id=1,
+            manufacturer_id=1,
+            part_type_id=part_t.id,
+        )
+        db.add(part)
+        await db.flush()
+        db.add(
+            AttachmentPoint(augmented_part_id=part.id, attachment_point_name_id=apn.id)
+        )
+        await db.commit()
+        part_id = part.id
+
+        perms = seeded["perms"]
+        editor = await role_crud.create(
+            db,
+            name="fit-recompute-editor",
+            permission_ids=[perms["fits:write"].id, perms["augmented_parts:read"].id],
+        )
+        editor_id = editor.id
+    await make_user("recomputer@example.com", role_ids=[editor_id])
+    await _web_login(client, "recomputer@example.com")
+
+    resp = await client.post(f"/admin/augmented-parts/{part_id}/fits/recompute")
+    assert resp.status_code == 200
+    assert f'id="ap-{part_id}-fits"' in resp.text
+    match = _JOB_URL_RE.search(resp.text)
+    assert match, resp.text
+
+    final_body = await _poll_until_done(client, match.group(1))
+    assert "created" in final_body and "removed" in final_body
+
+
+@pytest.mark.asyncio
+async def test_fit_recompute_all_runs_in_background(
+    client, seeded, make_user, db_sessionmaker, monkeypatch
+):
+    monkeypatch.setattr("app.web.admin.AsyncSessionLocal", db_sessionmaker)
+    async with db_sessionmaker() as db:
+        perms = seeded["perms"]
+        editor = await role_crud.create(
+            db, name="fit-recompute-all-editor", permission_ids=[perms["fits:write"].id]
+        )
+        editor_id = editor.id
+    await make_user("recomputerall@example.com", role_ids=[editor_id])
+    await _web_login(client, "recomputerall@example.com")
+
+    resp = await client.post("/admin/augmented-parts/fits/recompute")
+    assert resp.status_code == 200
+    assert "fits-recompute-status" in resp.text
+    match = _JOB_URL_RE.search(resp.text)
+    assert match, resp.text
+
+    final_body = await _poll_until_done(client, match.group(1))
+    assert "Recompute complete" in final_body

tests/test_fit_matching.py

@@ -34,20 +34,40 @@ def test_same_label_never_matches_even_with_identical_threads():
 
 
 def test_unc_thread_exact_match():
-    a = _ap(1, 1, unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC))
+    a = _ap(
-    b = _ap(2, 2, unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC))
+        1,
+        1,
+        unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC),
+    )
+    b = _ap(
+        2,
+        2,
+        unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC),
+    )
     assert attachment_points_match(a, b)
 
 
 def test_unc_thread_series_mismatch():
-    a = _ap(1, 1, unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC))
+    a = _ap(
-    b = _ap(2, 2, unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNF))
+        1,
+        1,
+        unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC),
+    )
+    b = _ap(
+        2,
+        2,
+        unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNF),
+    )
     assert not attachment_points_match(a, b)
 
 
 def test_iso_and_unc_never_match_each_other():
     a = _ap(1, 1, iso_thread=IsoThread(diameter_mm=8, pitch_mm=1.25))
-    b = _ap(2, 2, unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC))
+    b = _ap(
+        2,
+        2,
+        unc_thread=UncThread(diameter_fraction="1/4", tpi=20, series=UncSeries.UNC),
+    )
     assert not attachment_points_match(a, b)
 
 
@@ -94,9 +114,15 @@ def test_two_bare_attachment_points_never_match():
 
 
 def test_parts_could_fit_requires_different_types_and_identity():
-    a = AugmentedPart(id=1, part_type_id=1, description="a", colour_id=1, manufacturer_id=1)
+    a = AugmentedPart(
-    b = AugmentedPart(id=2, part_type_id=1, description="b", colour_id=1, manufacturer_id=1)
+        id=1, part_type_id=1, description="a", colour_id=1, manufacturer_id=1
-    c = AugmentedPart(id=3, part_type_id=2, description="c", colour_id=1, manufacturer_id=1)
+    )
+    b = AugmentedPart(
+        id=2, part_type_id=1, description="b", colour_id=1, manufacturer_id=1
+    )
+    c = AugmentedPart(
+        id=3, part_type_id=2, description="c", colour_id=1, manufacturer_id=1
+    )
     assert not parts_could_fit(a, b)
     assert parts_could_fit(a, c)
     assert not parts_could_fit(a, a)

tests/test_ldap_login.py

@@ -80,9 +80,7 @@ async def test_ldap_login_is_idempotent(
         assert await user_crud.count(db) == 1
 
 
-async def test_ldap_login_bad_credentials(
+async def test_ldap_login_bad_credentials(client, seeded, monkeypatch, ldap_enabled):
-    client, seeded, monkeypatch, ldap_enabled
-):
     async def fake_authenticate(username, password):
         return None
 

tests/test_scope_guide.py

@@ -31,7 +31,9 @@ async def _seed_guide_data(db):
         db.add(p)
         return p
 
-    s1 = part("Alpha 3-18x50", scope_t.id, manufacturer_id=10, sub_part_type_id=rifle.id)
+    s1 = part(
+        "Alpha 3-18x50", scope_t.id, manufacturer_id=10, sub_part_type_id=rifle.id
+    )
     s2 = part("Zeta 1-6x24", scope_t.id, manufacturer_id=20, sub_part_type_id=reddot.id)
     fc1 = part("Flip cover 50mm", cover_t.id)
     a1 = part("ARD 50mm", ard_t.id)
@@ -43,6 +45,7 @@ async def _seed_guide_data(db):
             augmented_part_id=s1.id,
             magnification_min=3,
             magnification_max=18,
+            objective_lens_diameter_mm=50,
             objective_thread_pitch="M52x0.75",
         )
     )
@@ -169,9 +172,7 @@ async def test_build_filters_by_required_fit_type(db_sessionmaker):
 
 
 async def _web_login(client, email, password="secret123"):
-    resp = await client.post(
+    resp = await client.post("/login", data={"email": email, "password": password})
-        "/login", data={"email": email, "password": password}
-    )
     assert resp.status_code == 303
 
 
@@ -199,7 +200,31 @@ async def test_scopes_page_renders_rows_and_fits(
     assert "Flip cover 50mm" in body  # a matching part in a fit column
     assert "fit-badge-exact" in body  # the exact fit badge
     assert "M52x0.75" in body  # scope info: objective thread
-    assert "3–18×" in body  # magnification range, integral values un-padded
+    assert "3-18" in body  # magnification range, integral values un-padded
+
+
+@pytest.mark.asyncio
+async def test_build_includes_objective_lens_diameter(db_sessionmaker):
+    async with db_sessionmaker() as db:
+        await _seed_guide_data(db)
+        guide = await scope_guide.build(db)
+
+    rows = {r["scope"].description: r for r in guide["rows"]}
+    assert rows["Alpha 3-18x50"]["info"].objective_lens_diameter_mm == 50
+    assert rows["Zeta 1-6x24"]["info"] is None
+
+
+@pytest.mark.asyncio
+async def test_scopes_page_renders_objective_lens_diameter_in_magnification(
+    client, seeded, make_user, db_sessionmaker
+):
+    async with db_sessionmaker() as db:
+        await _seed_guide_data(db)
+    await make_user("reader4@example.com", role_ids=[seeded["roles"]["user"].id])
+    await _web_login(client, "reader4@example.com")
+    resp = await client.get("/scopes")
+    assert resp.status_code == 200
+    assert "3-18x50" in resp.text
 
 
 @pytest.mark.asyncio

tests/test_scope_import.py

@@ -19,7 +19,7 @@ HEADERS = [
     "model",
     "magnification_min",
     "magnification_max",
-    "objective_lens_outside_diameter_mm",
+    "objective_lens_diameter_mm",
     "model_suffix",
     "sub_part_type",
     "product_number",
@@ -52,7 +52,7 @@ def _scope_row(**overrides):
         "model": "Viper",
         "magnification_min": 5,
         "magnification_max": 25,
-        "objective_lens_outside_diameter_mm": 56,
+        "objective_lens_diameter_mm": 56,
         "model_suffix": "PST",
         "sub_part_type": "Riflescope",
         "product_number": "SCOPE-A",
@@ -141,6 +141,7 @@ async def test_import_creates_scope_with_info_and_attachment_points(db_sessionma
         assert info.magnification_min == 5
         assert info.magnification_max == 25
         assert info.model_suffix == "PST"
+        assert info.objective_lens_diameter_mm == 56
         assert info.objective_thread_pitch == "0.75"
 
         aps = await attachment_point_crud.list_for_augmented_part(db, part.id)
@@ -151,14 +152,13 @@ async def test_import_creates_scope_with_info_and_attachment_points(db_sessionma
         assert len(by_label["Ocular"]) == 1
         assert by_label["Ocular"][0].static_connection.od_mm == 40
 
+        # The lens diameter is descriptive only: the sole Objective point is the
+        # thread.
         objectives = by_label["Objective"]
-        assert len(objectives) == 2  # static OD + thread
+        assert len(objectives) == 1
-        static_obj = [a for a in objectives if a.static_connection is not None]
+        assert objectives[0].static_connection is None
-        thread_obj = [a for a in objectives if a.iso_thread is not None]
+        assert objectives[0].iso_thread.diameter_mm == 40
-        assert static_obj and static_obj[0].static_connection.od_mm == 56
+        assert objectives[0].iso_thread.pitch_mm == 0.75
-        assert thread_obj
-        assert thread_obj[0].iso_thread.diameter_mm == 40
-        assert thread_obj[0].iso_thread.pitch_mm == 0.75
 
 
 async def test_import_resolves_ocular_and_objective_fits(db_sessionmaker):
@@ -200,7 +200,7 @@ async def test_import_upserts_on_product_number(db_sessionmaker):
 
         # Attachment points were rebuilt, not duplicated.
         aps = await attachment_point_crud.list_for_augmented_part(db, matching[0].id)
-        assert len(aps) == 3
+        assert len(aps) == 2
 
 
 async def test_row_without_product_number_is_skipped(db_sessionmaker):